Remove deprecated methods

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@754531 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Sebastian Bazley 2009-03-14 21:33:48 +00:00
parent 71711e3cf8
commit ef0dec934b
2 changed files with 6 additions and 523 deletions

View File

@ -93,7 +93,7 @@ import java.util.Locale;
*
* <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 @@ import java.util.Locale;
* @since 1.0
* @version $Id$
*/
//@Immutable
public class StringUtils {
// Performance testing notes (JDK 1.4, Jul03, scolebourne)
// Whitespace:
@ -259,29 +260,6 @@ public class StringUtils {
// Trim
//-----------------------------------------------------------------------
/**
* <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
@ -2034,61 +2012,6 @@ public class StringUtils {
// 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
//-----------------------------------------------------------------------
@ -2796,28 +2719,6 @@ public class StringUtils {
// 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>
@ -3144,39 +3045,6 @@ public class StringUtils {
// 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>
@ -3888,39 +3756,6 @@ public class StringUtils {
// Overlay
//-----------------------------------------------------------------------
/**
* <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>
*
@ -4071,103 +3906,6 @@ public class StringUtils {
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 @@ public class StringUtils {
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
//-----------------------------------------------------------------------
@ -4835,19 +4528,6 @@ public class StringUtils {
.toString();
}
/**
* <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>
@ -4879,19 +4559,6 @@ public class StringUtils {
.toString();
}
/**
* <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 @@ public class StringUtils {
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 @@ public class StringUtils {
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
//-----------------------------------------------------------------------
/**

View File

@ -134,27 +134,12 @@ public class StringUtilsTest extends TestCase {
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 @@ public class StringUtilsTest extends TestCase {
"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 @@ public class StringUtilsTest extends TestCase {
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 @@ public class StringUtilsTest extends TestCase {
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 @@ public class StringUtilsTest extends TestCase {
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 @@ public class StringUtilsTest extends TestCase {
"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 @@ public class StringUtilsTest extends TestCase {
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 @@ public class StringUtilsTest extends TestCase {
"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 @@ public class StringUtilsTest extends TestCase {
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));
@ -1517,18 +1394,6 @@ public class StringUtilsTest extends TestCase {
assertNull(StringUtils.defaultIfEmpty("", null));
}
//-----------------------------------------------------------------------
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));
@ -1547,6 +1412,7 @@ public class StringUtilsTest extends TestCase {
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 @@ public class StringUtilsTest extends TestCase {
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) {