commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From s...@apache.org
Subject svn commit: r754531 - in /commons/proper/lang/trunk/src: java/org/apache/commons/lang/StringUtils.java test/org/apache/commons/lang/StringUtilsTest.java
Date Sat, 14 Mar 2009 21:33:49 GMT
Author: sebb
Date: Sat Mar 14 21:33:48 2009
New Revision: 754531

URL: http://svn.apache.org/viewvc?rev=754531&view=rev
Log:
Remove deprecated methods

Modified:
    commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java
    commons/proper/lang/trunk/src/test/org/apache/commons/lang/StringUtilsTest.java

Modified: commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java?rev=754531&r1=754530&r2=754531&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java (original)
+++ commons/proper/lang/trunk/src/java/org/apache/commons/lang/StringUtils.java Sat Mar 14
21:33:48 2009
@@ -93,7 +93,7 @@
  *
  * <p>A side effect of the <code>null</code> handling is that a
  * <code>NullPointerException</code> should be considered a bug in
- * <code>StringUtils</code> (except for deprecated methods).</p>
+ * <code>StringUtils</code>.</p>
  *
  * <p>Methods in this class give sample code to explain their operation.
  * The symbol <code>*</code> is used to indicate any input including <code>null</code>.</p>
@@ -121,6 +121,7 @@
  * @since 1.0
  * @version $Id$
  */
+//@Immutable
 public class StringUtils {
     // Performance testing notes (JDK 1.4, Jul03, scolebourne)
     // Whitespace:
@@ -262,29 +263,6 @@
     /**
      * <p>Removes control characters (char &lt;= 32) from both
      * ends of this String, handling <code>null</code> by returning
-     * an empty String ("").</p>
-     *
-     * <pre>
-     * StringUtils.clean(null)          = ""
-     * StringUtils.clean("")            = ""
-     * StringUtils.clean("abc")         = "abc"
-     * StringUtils.clean("    abc    ") = "abc"
-     * StringUtils.clean("     ")       = ""
-     * </pre>
-     *
-     * @see java.lang.String#trim()
-     * @param str  the String to clean, may be null
-     * @return the trimmed text, never <code>null</code>
-     * @deprecated Use the clearer named {@link #trimToEmpty(String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String clean(String str) {
-        return str == null ? EMPTY : str.trim();
-    }
-
-    /**
-     * <p>Removes control characters (char &lt;= 32) from both
-     * ends of this String, handling <code>null</code> by returning
      * <code>null</code>.</p>
      *
      * <p>The String is trimmed using {@link String#trim()}.
@@ -2034,61 +2012,6 @@
 
     // Nested extraction
     //-----------------------------------------------------------------------
-    /**
-     * <p>Gets the String that is nested in between two instances of the
-     * same String.</p>
-     *
-     * <p>A <code>null</code> input String returns <code>null</code>.
-     * A <code>null</code> tag returns <code>null</code>.</p>
-     *
-     * <pre>
-     * StringUtils.getNestedString(null, *)            = null
-     * StringUtils.getNestedString("", "")             = ""
-     * StringUtils.getNestedString("", "tag")          = null
-     * StringUtils.getNestedString("tagabctag", null)  = null
-     * StringUtils.getNestedString("tagabctag", "")    = ""
-     * StringUtils.getNestedString("tagabctag", "tag") = "abc"
-     * </pre>
-     *
-     * @param str  the String containing nested-string, may be null
-     * @param tag  the String before and after nested-string, may be null
-     * @return the nested String, <code>null</code> if no match
-     * @deprecated Use the better named {@link #substringBetween(String, String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String getNestedString(String str, String tag) {
-        return substringBetween(str, tag, tag);
-    }
-
-    /**
-     * <p>Gets the String that is nested in between two Strings.
-     * Only the first match is returned.</p>
-     *
-     * <p>A <code>null</code> input String returns <code>null</code>.
-     * A <code>null</code> open/close returns <code>null</code> (no
match).
-     * An empty ("") open/close returns an empty string.</p>
-     *
-     * <pre>
-     * StringUtils.getNestedString(null, *, *)          = null
-     * StringUtils.getNestedString("", "", "")          = ""
-     * StringUtils.getNestedString("", "", "tag")       = null
-     * StringUtils.getNestedString("", "tag", "tag")    = null
-     * StringUtils.getNestedString("yabcz", null, null) = null
-     * StringUtils.getNestedString("yabcz", "", "")     = ""
-     * StringUtils.getNestedString("yabcz", "y", "z")   = "abc"
-     * StringUtils.getNestedString("yabczyabcz", "y", "z")   = "abc"
-     * </pre>
-     *
-     * @param str  the String containing nested-string, may be null
-     * @param open  the String before nested-string, may be null
-     * @param close  the String after nested-string, may be null
-     * @return the nested String, <code>null</code> if no match
-     * @deprecated Use the better named {@link #substringBetween(String, String, String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String getNestedString(String str, String open, String close) {
-        return substringBetween(str, open, close);
-    }
 
     // Splitting
     //-----------------------------------------------------------------------
@@ -2797,28 +2720,6 @@
     // Joining
     //-----------------------------------------------------------------------
     /**
-     * <p>Concatenates elements of an array into a single String.
-     * Null objects or empty strings within the array are represented by
-     * empty strings.</p>
-     *
-     * <pre>
-     * StringUtils.concatenate(null)            = null
-     * StringUtils.concatenate([])              = ""
-     * StringUtils.concatenate([null])          = ""
-     * StringUtils.concatenate(["a", "b", "c"]) = "abc"
-     * StringUtils.concatenate([null, "", "a"]) = "a"
-     * </pre>
-     *
-     * @param array  the array of values to concatenate, may be null
-     * @return the concatenated String, <code>null</code> if null array input
-     * @deprecated Use the better named {@link #join(Object[])} instead.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String concatenate(Object[] array) {
-        return join(array, null);
-    }
-
-    /**
      * <p>Joins the elements of the provided array into a single String
      * containing the provided list of elements.</p>
      *
@@ -3145,39 +3046,6 @@
     // Delete
     //-----------------------------------------------------------------------
     /**
-     * <p>Deletes all 'space' characters from a String as defined by
-     * {@link Character#isSpace(char)}.</p>
-     *
-     * <p>This is the only StringUtils method that uses the
-     * <code>isSpace</code> definition. You are advised to use
-     * {@link #deleteWhitespace(String)} instead as whitespace is much
-     * better localized.</p>
-     *
-     * <pre>
-     * StringUtils.deleteSpaces(null)           = null
-     * StringUtils.deleteSpaces("")             = ""
-     * StringUtils.deleteSpaces("abc")          = "abc"
-     * StringUtils.deleteSpaces(" \t  abc \n ") = "abc"
-     * StringUtils.deleteSpaces("ab  c")        = "abc"
-     * StringUtils.deleteSpaces("a\nb\tc     ") = "abc"
-     * </pre>
-     *
-     * <p>Spaces are defined as <code>{' ', '\t', '\r', '\n', '\b'}</code>
-     * in line with the deprecated <code>isSpace</code> method.</p>
-     *
-     * @param str  the String to delete spaces from, may be null
-     * @return the String without 'spaces', <code>null</code> if null String
input
-     * @deprecated Use the better localized {@link #deleteWhitespace(String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String deleteSpaces(String str) {
-        if (str == null) {
-            return null;
-        }
-        return CharSetUtils.delete(str, " \t\r\n\b");
-    }
-
-    /**
      * <p>Deletes all whitespaces from a String as defined by
      * {@link Character#isWhitespace(char)}.</p>
      *
@@ -3891,39 +3759,6 @@
     /**
      * <p>Overlays part of a String with another String.</p>
      *
-     * <pre>
-     * StringUtils.overlayString(null, *, *, *)           = NullPointerException
-     * StringUtils.overlayString(*, null, *, *)           = NullPointerException
-     * StringUtils.overlayString("", "abc", 0, 0)         = "abc"
-     * StringUtils.overlayString("abcdef", null, 2, 4)    = "abef"
-     * StringUtils.overlayString("abcdef", "", 2, 4)      = "abef"
-     * StringUtils.overlayString("abcdef", "zzzz", 2, 4)  = "abzzzzef"
-     * StringUtils.overlayString("abcdef", "zzzz", 4, 2)  = "abcdzzzzcdef"
-     * StringUtils.overlayString("abcdef", "zzzz", -1, 4) = IndexOutOfBoundsException
-     * StringUtils.overlayString("abcdef", "zzzz", 2, 8)  = IndexOutOfBoundsException
-     * </pre>
-     *
-     * @param text  the String to do overlaying in, may be null
-     * @param overlay  the String to overlay, may be null
-     * @param start  the position to start overlaying at, must be valid
-     * @param end  the position to stop overlaying before, must be valid
-     * @return overlayed String, <code>null</code> if null String input
-     * @throws NullPointerException if text or overlay is null
-     * @throws IndexOutOfBoundsException if either position is invalid
-     * @deprecated Use better named {@link #overlay(String, String, int, int)} instead.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String overlayString(String text, String overlay, int start, int end) {
-        return new StringBuffer(start + overlay.length() + text.length() - end + 1)
-            .append(text.substring(0, start))
-            .append(overlay)
-            .append(text.substring(end))
-            .toString();
-    }
-
-    /**
-     * <p>Overlays part of a String with another String.</p>
-     *
      * <p>A <code>null</code> string input returns <code>null</code>.
      * A negative index is treated as zero.
      * An index greater than the string length is treated as the string length.
@@ -4071,103 +3906,6 @@
         return str;
     }
 
-    /**
-     * <p>Remove any &quot;\n&quot; if and only if it is at the end
-     * of the supplied String.</p>
-     *
-     * @param str  the String to chomp from, must not be null
-     * @return String without chomped ending
-     * @throws NullPointerException if str is <code>null</code>
-     * @deprecated Use {@link #chomp(String)} instead.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String chompLast(String str) {
-        return chompLast(str, "\n");
-    }
-
-    /**
-     * <p>Remove a value if and only if the String ends with that value.</p>
-     *
-     * @param str  the String to chomp from, must not be null
-     * @param sep  the String to chomp, must not be null
-     * @return String without chomped ending
-     * @throws NullPointerException if str or sep is <code>null</code>
-     * @deprecated Use {@link #chomp(String,String)} instead.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String chompLast(String str, String sep) {
-        if (str.length() == 0) {
-            return str;
-        }
-        String sub = str.substring(str.length() - sep.length());
-        if (sep.equals(sub)) {
-            return str.substring(0, str.length() - sep.length());
-        }
-        return str;
-    }
-
-    /**
-     * <p>Remove everything and return the last value of a supplied String, and
-     * everything after it from a String.</p>
-     *
-     * @param str  the String to chomp from, must not be null
-     * @param sep  the String to chomp, must not be null
-     * @return String chomped
-     * @throws NullPointerException if str or sep is <code>null</code>
-     * @deprecated Use {@link #substringAfterLast(String, String)} instead
-     *             (although this doesn't include the separator)
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String getChomp(String str, String sep) {
-        int idx = str.lastIndexOf(sep);
-        if (idx == str.length() - sep.length()) {
-            return sep;
-        } else if (idx != -1) {
-            return str.substring(idx);
-        } else {
-            return EMPTY;
-        }
-    }
-
-    /**
-     * <p>Remove the first value of a supplied String, and everything before it
-     * from a String.</p>
-     *
-     * @param str  the String to chomp from, must not be null
-     * @param sep  the String to chomp, must not be null
-     * @return String without chomped beginning
-     * @throws NullPointerException if str or sep is <code>null</code>
-     * @deprecated Use {@link #substringAfter(String,String)} instead.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String prechomp(String str, String sep) {
-        int idx = str.indexOf(sep);
-        if (idx == -1) {
-            return str;
-        }             
-        return str.substring(idx + sep.length());
-    }
-
-    /**
-     * <p>Remove and return everything before the first value of a
-     * supplied String from another String.</p>
-     *
-     * @param str  the String to chomp from, must not be null
-     * @param sep  the String to chomp, must not be null
-     * @return String prechomped
-     * @throws NullPointerException if str or sep is <code>null</code>
-     * @deprecated Use {@link #substringBefore(String,String)} instead
-     *             (although this doesn't include the separator).
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String getPrechomp(String str, String sep) {
-        int idx = str.indexOf(sep);
-        if (idx == -1) {
-            return EMPTY;
-        } 
-        return str.substring(0, idx + sep.length());
-    }
-
     // Chopping
     //-----------------------------------------------------------------------
     /**
@@ -4212,53 +3950,8 @@
         return ret;
     }
 
-    /**
-     * <p>Removes <code>\n</code> from end of a String if it's there.
-     * If a <code>\r</code> precedes it, then remove that too.</p>
-     *
-     * @param str  the String to chop a newline from, must not be null
-     * @return String without newline
-     * @throws NullPointerException if str is <code>null</code>
-     * @deprecated Use {@link #chomp(String)} instead.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String chopNewline(String str) {
-        int lastIdx = str.length() - 1;
-        if (lastIdx <= 0) {
-            return EMPTY;
-        }
-        char last = str.charAt(lastIdx);
-        if (last == CharUtils.LF) {
-            if (str.charAt(lastIdx - 1) == CharUtils.CR) {
-                lastIdx--;
-            }
-        } else {
-            lastIdx++;
-        }
-        return str.substring(0, lastIdx);
-    }
-
     // Conversion
     //-----------------------------------------------------------------------
-    /**
-     * <p>Escapes any values it finds into their String form.</p>
-     *
-     * <p>So a tab becomes the characters <code>'\\'</code> and
-     * <code>'t'</code>.</p>
-     *
-     * <p>As of Lang 2.0, this calls {@link StringEscapeUtils#escapeJava(String)}
-     * behind the scenes.
-     * </p>
-     * @see StringEscapeUtils#escapeJava(java.lang.String)
-     * @param str String to escape values in
-     * @return String with escaped values
-     * @throws NullPointerException if str is <code>null</code>
-     * @deprecated Use {@link StringEscapeUtils#escapeJava(String)}
-     *             This method will be removed in Commons Lang 3.0
-     */
-    public static String escape(String str) {
-        return StringEscapeUtils.escapeJava(str);
-    }
 
     // Padding
     //-----------------------------------------------------------------------
@@ -4836,19 +4529,6 @@
     }
 
     /**
-     * <p>Capitalizes a String changing the first letter to title case as
-     * per {@link Character#toTitleCase(char)}. No other letters are changed.</p>
-     *
-     * @param str  the String to capitalize, may be null
-     * @return the capitalized String, <code>null</code> if null String input
-     * @deprecated Use the standardly named {@link #capitalize(String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String capitalise(String str) {
-        return capitalize(str);
-    }
-
-    /**
      * <p>Uncapitalizes a String changing the first letter to title case as
      * per {@link Character#toLowerCase(char)}. No other letters are changed.</p>
      *
@@ -4880,19 +4560,6 @@
     }
 
     /**
-     * <p>Uncapitalizes a String changing the first letter to title case as
-     * per {@link Character#toLowerCase(char)}. No other letters are changed.</p>
-     *
-     * @param str  the String to uncapitalize, may be null
-     * @return the uncapitalized String, <code>null</code> if null String input
-     * @deprecated Use the standardly named {@link #uncapitalize(String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String uncapitalise(String str) {
-        return uncapitalize(str);
-    }
-
-    /**
      * <p>Swaps the case of a String changing upper and title case to
      * lower case, and lower case to upper case.</p>
      *
@@ -4941,22 +4608,6 @@
         return buffer.toString();
     }
 
-    /**
-     * <p>Capitalizes all the whitespace separated words in a String.
-     * Only the first letter of each word is changed.</p>
-     *
-     * <p>Whitespace is defined by {@link Character#isWhitespace(char)}.
-     * A <code>null</code> input String returns <code>null</code>.</p>
-     *
-     * @param str  the String to capitalize, may be null
-     * @return capitalized String, <code>null</code> if null String input
-     * @deprecated Use the relocated {@link WordUtils#capitalize(String)}.
-     *             Method will be removed in Commons Lang 3.0.
-     */
-    public static String capitaliseAllWords(String str) {
-        return WordUtils.capitalize(str);
-    }
-
     // Count matches
     //-----------------------------------------------------------------------
     /**
@@ -5382,42 +5033,6 @@
         return join(strs, separatorChar);
     }
 
-    /**
-     * <p>Reverses a String that is delimited by a specific character.</p>
-     *
-     * <p>The Strings between the delimiters are not reversed.
-     * Thus java.lang.String becomes String.lang.java (if the delimiter
-     * is <code>"."</code>).</p>
-     *
-     * <pre>
-     * StringUtils.reverseDelimitedString(null, *)       = null
-     * StringUtils.reverseDelimitedString("",*)          = ""
-     * StringUtils.reverseDelimitedString("a.b.c", null) = "a.b.c"
-     * StringUtils.reverseDelimitedString("a.b.c", ".")  = "c.b.a"
-     * </pre>
-     *
-     * @param str  the String to reverse, may be null
-     * @param separatorChars  the separator characters to use, null treated as whitespace
-     * @return the reversed String, <code>null</code> if null String input
-     * @deprecated Use {@link #reverseDelimited(String, char)} instead.
-     *      This method is broken as the join doesn't know which char to use.
-     *      Method will be removed in Commons Lang 3.0.
-     *
-     */
-    public static String reverseDelimitedString(String str, String separatorChars) {
-        if (str == null) {
-            return null;
-        }
-        // could implement manually, but simple way is to reuse other,
-        // probably slower, methods.
-        String[] strs = split(str, separatorChars);
-        ArrayUtils.reverse(strs);
-        if (separatorChars == null) {
-            return join(strs, ' ');
-        }
-        return join(strs, separatorChars);
-    }
-
     // Abbreviating
     //-----------------------------------------------------------------------
     /**

Modified: commons/proper/lang/trunk/src/test/org/apache/commons/lang/StringUtilsTest.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/test/org/apache/commons/lang/StringUtilsTest.java?rev=754531&r1=754530&r2=754531&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/test/org/apache/commons/lang/StringUtilsTest.java (original)
+++ commons/proper/lang/trunk/src/test/org/apache/commons/lang/StringUtilsTest.java Sat Mar
14 21:33:48 2009
@@ -134,27 +134,12 @@
         assertEquals(null, StringUtils.lowerCase(null));
         assertEquals(null, StringUtils.lowerCase(null, Locale.ENGLISH));
         assertEquals(null, StringUtils.capitalize(null));
-        assertEquals(null, StringUtils.uncapitalise(null));
         assertEquals(null, StringUtils.uncapitalize(null));
 
-        assertEquals("capitalise(String) failed",
-                    FOO_CAP, StringUtils.capitalise(FOO_UNCAP) );
-        assertEquals("capitalise(empty-string) failed",
-                    "", StringUtils.capitalise("") );
-        assertEquals("capitalise(single-char-string) failed",
-                    "X", StringUtils.capitalise("x") );
-        assertEquals("capitalize(String) failed",
-                     FOO_CAP, StringUtils.capitalize(FOO_UNCAP) );
         assertEquals("capitalize(empty-string) failed",
                      "", StringUtils.capitalize("") );
         assertEquals("capitalize(single-char-string) failed",
                      "X", StringUtils.capitalize("x") );
-        assertEquals("uncapitalise(String) failed",
-                     FOO_UNCAP, StringUtils.uncapitalise(FOO_CAP) );
-        assertEquals("uncapitalise(empty-string) failed",
-                     "", StringUtils.uncapitalise("") );
-        assertEquals("uncapitalise(single-char-string) failed",
-                     "x", StringUtils.uncapitalise("X") );
         assertEquals("uncapitalize(String) failed",
                      FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP) );
         assertEquals("uncapitalize(empty-string) failed",
@@ -163,20 +148,12 @@
                      "x", StringUtils.uncapitalize("X") );
                      
         // reflection type of tests: Sentences.
-        assertEquals("uncapitalise(capitalise(String)) failed",
-                     SENTENCE_UNCAP, StringUtils.uncapitalise(StringUtils.capitalise(SENTENCE_UNCAP))
);
-        assertEquals("capitalise(uncapitalise(String)) failed",
-                     SENTENCE_CAP, StringUtils.capitalise(StringUtils.uncapitalise(SENTENCE_CAP))
);
         assertEquals("uncapitalize(capitalize(String)) failed",
                      SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP))
);
         assertEquals("capitalize(uncapitalize(String)) failed",
                      SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP))
);
 
         // reflection type of tests: One word.
-        assertEquals("uncapitalise(capitalise(String)) failed",
-                     FOO_UNCAP, StringUtils.uncapitalise(StringUtils.capitalise(FOO_UNCAP))
);
-        assertEquals("capitalise(uncapitalise(String)) failed",
-                     FOO_CAP, StringUtils.capitalise(StringUtils.uncapitalise(FOO_CAP)) );
         assertEquals("uncapitalize(capitalize(String)) failed",
                      FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP))
);
         assertEquals("capitalize(uncapitalize(String)) failed",
@@ -314,14 +291,6 @@
         assertEquals(TEXT_LIST, StringUtils.join(Arrays.asList(ARRAY_LIST), SEPARATOR));
     }
 
-    public void testDeprecatedConcatenate_Objectarray() {
-        assertEquals(null, StringUtils.concatenate(null));
-        assertEquals("", StringUtils.concatenate(EMPTY_ARRAY_LIST));
-        assertEquals("", StringUtils.concatenate(NULL_ARRAY_LIST));
-        assertEquals("foo", StringUtils.concatenate(MIXED_ARRAY_LIST));
-        assertEquals("foo2", StringUtils.concatenate(MIXED_TYPE_LIST));
-    }
-        
     public void testSplit_String() {
         assertEquals(null, StringUtils.split(null));
         assertEquals(0, StringUtils.split("").length);
@@ -450,7 +419,7 @@
         String stringToSplitOnNulls = "ab   de fg" ;
         String[] splitOnNullExpectedResults = { "ab", "de", "fg" } ;
 
-        String[] splitOnNullResults = StringUtils.splitByWholeSeparator( "ab   de fg", null
) ;
+        String[] splitOnNullResults = StringUtils.splitByWholeSeparator( stringToSplitOnNulls,
null ) ;
         assertEquals( splitOnNullExpectedResults.length, splitOnNullResults.length ) ;
         for ( int i = 0 ; i < splitOnNullExpectedResults.length ; i+= 1 ) {
             assertEquals( splitOnNullExpectedResults[i], splitOnNullResults[i] ) ;
@@ -958,13 +927,6 @@
                 StringUtils.splitByCharacterTypeCamelCase("ASFRules")));
     }
 
-    public void testDeprecatedDeleteSpace_String() {
-        assertEquals(null, StringUtils.deleteSpaces(null));
-        assertEquals("", StringUtils.deleteSpaces(""));
-        assertEquals("", StringUtils.deleteSpaces("    \t\t\n\n   "));
-        assertEquals("test", StringUtils.deleteSpaces("t  \t\ne\rs\n\n   \tt"));
-    }
-    
     public void testDeleteWhitespace_String() {
         assertEquals(null, StringUtils.deleteWhitespace(null));
         assertEquals("", StringUtils.deleteWhitespace(""));
@@ -1153,30 +1115,6 @@
             "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM567891234"));
     }
     
-    public void testDeprecatedOverlayString_StringStringIntInt() {
-        assertEquals("overlayString(String, String, int, int) failed",
-                     "foo foor baz", StringUtils.overlayString(SENTENCE_UNCAP, FOO_UNCAP,
4, 6) );
-        assertEquals("abef", StringUtils.overlayString("abcdef", "", 2, 4));
-        assertEquals("abzzzzef", StringUtils.overlayString("abcdef", "zzzz", 2, 4));
-        assertEquals("abcdzzzzcdef", StringUtils.overlayString("abcdef", "zzzz", 4, 2));
-        try {
-            StringUtils.overlayString(null, "zzzz", 2, 4);
-            fail();
-        } catch (NullPointerException ex) {}
-        try {
-            StringUtils.overlayString("abcdef", null, 2, 4);
-            fail();
-        } catch (NullPointerException ex) {}
-        try {
-            StringUtils.overlayString("abcdef", "zzzz", -1, 4);
-            fail();
-        } catch (IndexOutOfBoundsException ex) {}
-        try {
-            StringUtils.overlayString("abcdef", "zzzz", 2, 8);
-            fail();
-        } catch (IndexOutOfBoundsException ex) {}
-    }
-
     public void testOverlay_StringStringIntInt() {
         assertEquals(null, StringUtils.overlay(null, null, 2, 4));
         assertEquals(null, StringUtils.overlay(null, null, -2, -4));
@@ -1216,36 +1154,6 @@
         assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'}));
     }
 
-    public void testDeprecatedChompFunctions() {
-        assertEquals("chompLast(String) failed",
-                     FOO_UNCAP, StringUtils.chompLast(FOO_UNCAP + "\n") );
-
-        assertEquals("chompLast(\"\") failed",
-            "", StringUtils.chompLast("") );
-        assertEquals("chompLast(\"test\", \"test\") failed",
-            "test", StringUtils.chompLast("test", "tst") );
-        
-        assertEquals("getChomp(String, String) failed",
-                     "\n" + FOO_UNCAP, StringUtils.getChomp(FOO_UNCAP + "\n" + FOO_UNCAP,
"\n") );
-        assertEquals("getChomp(String, String) failed",
-                     FOO_CAP, StringUtils.getChomp(FOO_CAP+FOO_CAP, FOO_CAP));
-        assertEquals("getChomp(String, String) failed",
-                     "", StringUtils.getChomp(FOO_UNCAP, FOO_CAP));
-
-        assertEquals("prechomp(String, String) failed",
-                     FOO_UNCAP, StringUtils.prechomp(FOO_UNCAP + "\n" + FOO_UNCAP, "\n")
);
-        assertEquals("prechomp(String, String) failed",
-                     FOO_UNCAP, StringUtils.prechomp(FOO_UNCAP, FOO_CAP));
-        
-        assertEquals("getPrechomp(String, String) failed",
-                     FOO_UNCAP + "\n", StringUtils.getPrechomp(FOO_UNCAP + "\n" + FOO_UNCAP,
"\n") );
-        assertEquals("getPrechomp(String, String) failed",
-                     "", StringUtils.getPrechomp(FOO_CAP, FOO_UNCAP));
-        
-        assertEquals("chopNewline(String, String) failed",
-                     FOO_UNCAP, StringUtils.chopNewline(FOO_UNCAP + "\r\n") );
-    }
-
     public void testChop() {
 
         String[][] chopCases = {
@@ -1327,28 +1235,6 @@
                 "foo ", StringUtils.chomp("foo ", "foo"));
     }
 
-    public void testChopNewLine() {
-
-        String[][] newLineCases = {
-            { FOO_UNCAP + "\r\n", FOO_UNCAP } ,
-            { FOO_UNCAP + "\n" , FOO_UNCAP } ,
-            { FOO_UNCAP + "\r", FOO_UNCAP + "\r" },
-            { FOO_UNCAP, FOO_UNCAP },
-            { FOO_UNCAP + "\n" + FOO_UNCAP , FOO_UNCAP + "\n" + FOO_UNCAP },
-            { FOO_UNCAP + "\n\n", FOO_UNCAP + "\n"},
-            { "\n", "" },
-            { "", "" },
-            { "\r\n", "" }
-      };
-
-      for (int i = 0; i < newLineCases.length; i++) {
-          String original = newLineCases[i][0];
-          String expectedResult = newLineCases[i][1];
-          assertEquals("chopNewline(String) failed",
-                  expectedResult, StringUtils.chopNewline(original));
-      }
-    }
-
     //-----------------------------------------------------------------------
     public void testRightPad_StringInt() {
         assertEquals(null, StringUtils.rightPad(null, 5));
@@ -1488,15 +1374,6 @@
         assertEquals("", StringUtils.reverseDelimited("", '.') );
     }
 
-    public void testDeprecatedReverseDelimitedString_StringString() {
-        assertEquals(null, StringUtils.reverseDelimitedString(null, null) );
-        assertEquals("", StringUtils.reverseDelimitedString("", null) );
-        assertEquals("", StringUtils.reverseDelimitedString("", ".") );
-        assertEquals("a.b.c", StringUtils.reverseDelimitedString("a.b.c", null) );
-        assertEquals("c b a", StringUtils.reverseDelimitedString("a b c", null) );
-        assertEquals("c.b.a", StringUtils.reverseDelimitedString("a.b.c", ".") );
-    }
-
     //-----------------------------------------------------------------------
     public void testDefault_String() {
         assertEquals("", StringUtils.defaultString(null));
@@ -1518,18 +1395,6 @@
     }
 
     //-----------------------------------------------------------------------
-    public void testDeprecatedEscapeFunctions_String() {
-        assertEquals("", StringUtils.escape("") );
-        assertEquals("abc", StringUtils.escape("abc") );
-        assertEquals("\\t", StringUtils.escape("\t") );
-        assertEquals("\\\\", StringUtils.escape("\\") );
-        assertEquals("\\\\\\b\\t\\r", StringUtils.escape("\\\b\t\r") );
-        assertEquals("\\u1234", StringUtils.escape("\u1234") );
-        assertEquals("\\u0234", StringUtils.escape("\u0234") );
-        assertEquals("\\u00FD", StringUtils.escape("\u00fd") );
-    }
-
-    //-----------------------------------------------------------------------
     public void testAbbreviate_StringInt() {
         assertEquals(null, StringUtils.abbreviate(null, 10));
         assertEquals("", StringUtils.abbreviate("", 10));
@@ -1547,6 +1412,7 @@
         assertEquals("", StringUtils.abbreviate("", 4));
         
         try {
+            @SuppressWarnings("unused")
             String res = StringUtils.abbreviate("abc", 3);
             fail("StringUtils.abbreviate expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {
@@ -1560,12 +1426,14 @@
         assertEquals("", StringUtils.abbreviate("", 2, 10));
         
         try {
+            @SuppressWarnings("unused")
             String res = StringUtils.abbreviate("abcdefghij", 0, 3);
             fail("StringUtils.abbreviate expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {
                 // empty
         }      
         try {
+            @SuppressWarnings("unused")
             String res = StringUtils.abbreviate("abcdefghij", 5, 6);
             fail("StringUtils.abbreviate expecting IllegalArgumentException");
         } catch (IllegalArgumentException ex) {



Mime
View raw message