Format source code and remove spaces on empty lines
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
index ecc6afc..a83eed6 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
@@ -44,12 +44,13 @@
*/
@SuppressWarnings("deprecation") // deliberate use of deprecated code
public class StringUtilsTest {
-
+
static final String WHITESPACE;
static final String NON_WHITESPACE;
static final String HARD_SPACE;
static final String TRIMMABLE;
static final String NON_TRIMMABLE;
+
static {
String ws = "";
String nws = "";
@@ -76,16 +77,16 @@
NON_TRIMMABLE = ntr;
}
- private static final String[] ARRAY_LIST = { "foo", "bar", "baz" };
+ private static final String[] ARRAY_LIST = {"foo", "bar", "baz"};
private static final String[] EMPTY_ARRAY_LIST = {};
private static final String[] NULL_ARRAY_LIST = {null};
private static final Object[] NULL_TO_STRING_LIST = {
- new Object(){
- @Override
- public String toString() {
- return null;
+ new Object() {
+ @Override
+ public String toString() {
+ return null;
+ }
}
- }
};
private static final String[] MIXED_ARRAY_LIST = {null, "", "foo"};
private static final Object[] MIXED_TYPE_LIST = {"foo", Long.valueOf(2L)};
@@ -98,7 +99,7 @@
private static final double[] DOUBLE_PRIM_LIST = {1, 2};
private static final String SEPARATOR = ",";
- private static final char SEPARATOR_CHAR = ';';
+ private static final char SEPARATOR_CHAR = ';';
private static final String TEXT_LIST = "foo,bar,baz";
private static final String TEXT_LIST_CHAR = "foo;bar;baz";
@@ -120,94 +121,94 @@
assertTrue(Modifier.isPublic(StringUtils.class.getModifiers()));
assertFalse(Modifier.isFinal(StringUtils.class.getModifiers()));
}
-
+
//-----------------------------------------------------------------------
@Test
- public void testIsEmpty(){
- assertTrue(StringUtils.isEmpty(null));
- assertTrue(StringUtils.isEmpty(""));
- assertFalse(StringUtils.isEmpty(" "));
- assertFalse(StringUtils.isEmpty("bob"));
- assertFalse(StringUtils.isEmpty(" bob "));
+ public void testIsEmpty() {
+ assertTrue(StringUtils.isEmpty(null));
+ assertTrue(StringUtils.isEmpty(""));
+ assertFalse(StringUtils.isEmpty(" "));
+ assertFalse(StringUtils.isEmpty("bob"));
+ assertFalse(StringUtils.isEmpty(" bob "));
}
-
+
@Test
- public void testIsNotEmpty(){
- assertFalse(StringUtils.isNotEmpty(null));
- assertFalse(StringUtils.isNotEmpty(""));
- assertTrue(StringUtils.isNotEmpty(" "));
- assertTrue(StringUtils.isNotEmpty("bob"));
- assertTrue(StringUtils.isNotEmpty(" bob "));
+ public void testIsNotEmpty() {
+ assertFalse(StringUtils.isNotEmpty(null));
+ assertFalse(StringUtils.isNotEmpty(""));
+ assertTrue(StringUtils.isNotEmpty(" "));
+ assertTrue(StringUtils.isNotEmpty("bob"));
+ assertTrue(StringUtils.isNotEmpty(" bob "));
}
-
+
@Test
- public void testIsAnyEmpty(){
- assertTrue(StringUtils.isAnyEmpty((String) null));
- assertTrue(StringUtils.isAnyEmpty((String[]) null));
- assertTrue(StringUtils.isAnyEmpty(null, "foo"));
- assertTrue(StringUtils.isAnyEmpty("", "bar"));
- assertTrue(StringUtils.isAnyEmpty("bob", ""));
- assertTrue(StringUtils.isAnyEmpty(" bob ", null));
- assertFalse(StringUtils.isAnyEmpty(" ","bar"));
- assertFalse(StringUtils.isAnyEmpty("foo","bar"));
+ public void testIsAnyEmpty() {
+ assertTrue(StringUtils.isAnyEmpty((String) null));
+ assertTrue(StringUtils.isAnyEmpty((String[]) null));
+ assertTrue(StringUtils.isAnyEmpty(null, "foo"));
+ assertTrue(StringUtils.isAnyEmpty("", "bar"));
+ assertTrue(StringUtils.isAnyEmpty("bob", ""));
+ assertTrue(StringUtils.isAnyEmpty(" bob ", null));
+ assertFalse(StringUtils.isAnyEmpty(" ", "bar"));
+ assertFalse(StringUtils.isAnyEmpty("foo", "bar"));
}
-
+
@Test
- public void testIsNoneEmpty(){
- assertFalse(StringUtils.isNoneEmpty((String) null));
- assertFalse(StringUtils.isNoneEmpty((String[]) null));
- assertFalse(StringUtils.isNoneEmpty(null, "foo"));
- assertFalse(StringUtils.isNoneEmpty("", "bar"));
- assertFalse(StringUtils.isNoneEmpty("bob", ""));
- assertFalse(StringUtils.isNoneEmpty(" bob ", null));
- assertTrue(StringUtils.isNoneEmpty(" ", "bar"));
- assertTrue(StringUtils.isNoneEmpty("foo", "bar"));
+ public void testIsNoneEmpty() {
+ assertFalse(StringUtils.isNoneEmpty((String) null));
+ assertFalse(StringUtils.isNoneEmpty((String[]) null));
+ assertFalse(StringUtils.isNoneEmpty(null, "foo"));
+ assertFalse(StringUtils.isNoneEmpty("", "bar"));
+ assertFalse(StringUtils.isNoneEmpty("bob", ""));
+ assertFalse(StringUtils.isNoneEmpty(" bob ", null));
+ assertTrue(StringUtils.isNoneEmpty(" ", "bar"));
+ assertTrue(StringUtils.isNoneEmpty("foo", "bar"));
}
-
+
@Test
- public void testIsBlank(){
- assertTrue(StringUtils.isBlank(null));
- assertTrue(StringUtils.isBlank(""));
- assertTrue(StringUtils.isBlank(" "));
- assertFalse(StringUtils.isBlank("bob"));
- assertFalse(StringUtils.isBlank(" bob "));
+ public void testIsBlank() {
+ assertTrue(StringUtils.isBlank(null));
+ assertTrue(StringUtils.isBlank(""));
+ assertTrue(StringUtils.isBlank(" "));
+ assertFalse(StringUtils.isBlank("bob"));
+ assertFalse(StringUtils.isBlank(" bob "));
}
-
+
@Test
- public void testIsNotBlank(){
- assertFalse(StringUtils.isNotBlank(null));
- assertFalse(StringUtils.isNotBlank(""));
- assertFalse(StringUtils.isNotBlank(" "));
- assertTrue(StringUtils.isNotBlank("bob"));
- assertTrue(StringUtils.isNotBlank(" bob "));
+ public void testIsNotBlank() {
+ assertFalse(StringUtils.isNotBlank(null));
+ assertFalse(StringUtils.isNotBlank(""));
+ assertFalse(StringUtils.isNotBlank(" "));
+ assertTrue(StringUtils.isNotBlank("bob"));
+ assertTrue(StringUtils.isNotBlank(" bob "));
}
-
- @Test
- public void testIsAnyBlank(){
- assertTrue(StringUtils.isAnyBlank((String) null));
- assertTrue(StringUtils.isAnyBlank((String[]) null));
- assertTrue(StringUtils.isAnyBlank(null, "foo"));
- assertTrue(StringUtils.isAnyBlank(null, null));
- assertTrue(StringUtils.isAnyBlank("", "bar"));
- assertTrue(StringUtils.isAnyBlank("bob", ""));
- assertTrue(StringUtils.isAnyBlank(" bob ", null));
- assertTrue(StringUtils.isAnyBlank(" ","bar"));
- assertFalse(StringUtils.isAnyBlank("foo","bar"));
- }
-
+
@Test
- public void testIsNoneBlank(){
- assertFalse(StringUtils.isNoneBlank((String) null));
- assertFalse(StringUtils.isNoneBlank((String[]) null));
- assertFalse(StringUtils.isNoneBlank(null, "foo"));
- assertFalse(StringUtils.isNoneBlank(null, null));
- assertFalse(StringUtils.isNoneBlank("", "bar"));
- assertFalse(StringUtils.isNoneBlank("bob", ""));
- assertFalse(StringUtils.isNoneBlank(" bob ", null));
- assertFalse(StringUtils.isNoneBlank(" ", "bar"));
- assertTrue(StringUtils.isNoneBlank("foo", "bar"));
+ public void testIsAnyBlank() {
+ assertTrue(StringUtils.isAnyBlank((String) null));
+ assertTrue(StringUtils.isAnyBlank((String[]) null));
+ assertTrue(StringUtils.isAnyBlank(null, "foo"));
+ assertTrue(StringUtils.isAnyBlank(null, null));
+ assertTrue(StringUtils.isAnyBlank("", "bar"));
+ assertTrue(StringUtils.isAnyBlank("bob", ""));
+ assertTrue(StringUtils.isAnyBlank(" bob ", null));
+ assertTrue(StringUtils.isAnyBlank(" ", "bar"));
+ assertFalse(StringUtils.isAnyBlank("foo", "bar"));
}
-
+
+ @Test
+ public void testIsNoneBlank() {
+ assertFalse(StringUtils.isNoneBlank((String) null));
+ assertFalse(StringUtils.isNoneBlank((String[]) null));
+ assertFalse(StringUtils.isNoneBlank(null, "foo"));
+ assertFalse(StringUtils.isNoneBlank(null, null));
+ assertFalse(StringUtils.isNoneBlank("", "bar"));
+ assertFalse(StringUtils.isNoneBlank("bob", ""));
+ assertFalse(StringUtils.isNoneBlank(" bob ", null));
+ assertFalse(StringUtils.isNoneBlank(" ", "bar"));
+ assertTrue(StringUtils.isNoneBlank("foo", "bar"));
+ }
+
//-----------------------------------------------------------------------
@Test
public void testCaseFunctions() {
@@ -219,57 +220,57 @@
assertNull(StringUtils.uncapitalize(null));
assertEquals("capitalize(empty-string) failed",
- "", StringUtils.capitalize("") );
+ "", StringUtils.capitalize(""));
assertEquals("capitalize(single-char-string) failed",
- "X", StringUtils.capitalize("x") );
+ "X", StringUtils.capitalize("x"));
assertEquals("capitalize(String) failed",
- FOO_CAP, StringUtils.capitalize(FOO_CAP) );
+ FOO_CAP, StringUtils.capitalize(FOO_CAP));
assertEquals("capitalize(string) failed",
- FOO_CAP, StringUtils.capitalize(FOO_UNCAP) );
+ FOO_CAP, StringUtils.capitalize(FOO_UNCAP));
assertEquals("uncapitalize(String) failed",
- FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP) );
+ FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP));
assertEquals("uncapitalize(string) failed",
- FOO_UNCAP, StringUtils.uncapitalize(FOO_UNCAP) );
+ FOO_UNCAP, StringUtils.uncapitalize(FOO_UNCAP));
assertEquals("uncapitalize(empty-string) failed",
- "", StringUtils.uncapitalize("") );
+ "", StringUtils.uncapitalize(""));
assertEquals("uncapitalize(single-char-string) failed",
- "x", StringUtils.uncapitalize("X") );
-
+ "x", StringUtils.uncapitalize("X"));
+
// reflection type of tests: Sentences.
assertEquals("uncapitalize(capitalize(String)) failed",
- SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP)) );
+ SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP)));
assertEquals("capitalize(uncapitalize(String)) failed",
- SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP)) );
+ SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP)));
// reflection type of tests: One word.
assertEquals("uncapitalize(capitalize(String)) failed",
- FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP)) );
+ FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP)));
assertEquals("capitalize(uncapitalize(String)) failed",
- FOO_CAP, StringUtils.capitalize(StringUtils.uncapitalize(FOO_CAP)) );
+ FOO_CAP, StringUtils.capitalize(StringUtils.uncapitalize(FOO_CAP)));
assertEquals("upperCase(String) failed",
- "FOO TEST THING", StringUtils.upperCase("fOo test THING") );
+ "FOO TEST THING", StringUtils.upperCase("fOo test THING"));
assertEquals("upperCase(empty-string) failed",
- "", StringUtils.upperCase("") );
+ "", StringUtils.upperCase(""));
assertEquals("lowerCase(String) failed",
- "foo test thing", StringUtils.lowerCase("fOo test THING") );
+ "foo test thing", StringUtils.lowerCase("fOo test THING"));
assertEquals("lowerCase(empty-string) failed",
- "", StringUtils.lowerCase("") );
+ "", StringUtils.lowerCase(""));
assertEquals("upperCase(String, Locale) failed",
- "FOO TEST THING", StringUtils.upperCase("fOo test THING", Locale.ENGLISH) );
+ "FOO TEST THING", StringUtils.upperCase("fOo test THING", Locale.ENGLISH));
assertEquals("upperCase(empty-string, Locale) failed",
- "", StringUtils.upperCase("", Locale.ENGLISH) );
+ "", StringUtils.upperCase("", Locale.ENGLISH));
assertEquals("lowerCase(String, Locale) failed",
- "foo test thing", StringUtils.lowerCase("fOo test THING", Locale.ENGLISH) );
+ "foo test thing", StringUtils.lowerCase("fOo test THING", Locale.ENGLISH));
assertEquals("lowerCase(empty-string, Locale) failed",
- "", StringUtils.lowerCase("", Locale.ENGLISH) );
-
+ "", StringUtils.lowerCase("", Locale.ENGLISH));
+
// Examples from uncapitalize Javadoc
assertEquals("cat", StringUtils.uncapitalize("cat"));
- assertEquals("cat", StringUtils.uncapitalize("Cat"));
- assertEquals("cAT", StringUtils.uncapitalize("CAT"));
+ assertEquals("cat", StringUtils.uncapitalize("Cat"));
+ assertEquals("cAT", StringUtils.uncapitalize("CAT"));
}
@Test
@@ -277,14 +278,14 @@
assertNull(StringUtils.swapCase(null));
assertEquals("", StringUtils.swapCase(""));
assertEquals(" ", StringUtils.swapCase(" "));
-
- assertEquals("i", WordUtils.swapCase("I") );
- assertEquals("I", WordUtils.swapCase("i") );
- assertEquals("I AM HERE 123", StringUtils.swapCase("i am here 123") );
- assertEquals("i aM hERE 123", StringUtils.swapCase("I Am Here 123") );
- assertEquals("I AM here 123", StringUtils.swapCase("i am HERE 123") );
- assertEquals("i am here 123", StringUtils.swapCase("I AM HERE 123") );
-
+
+ assertEquals("i", WordUtils.swapCase("I"));
+ assertEquals("I", WordUtils.swapCase("i"));
+ assertEquals("I AM HERE 123", StringUtils.swapCase("i am here 123"));
+ assertEquals("i aM hERE 123", StringUtils.swapCase("I Am Here 123"));
+ assertEquals("I AM here 123", StringUtils.swapCase("i am HERE 123"));
+ assertEquals("i am here 123", StringUtils.swapCase("I AM HERE 123"));
+
final String test = "This String contains a TitleCase character: \u01C8";
final String expect = "tHIS sTRING CONTAINS A tITLEcASE CHARACTER: \u01C9";
assertEquals(expect, WordUtils.swapCase(test));
@@ -294,8 +295,8 @@
@Test
public void testJoin_Objects() {
assertEquals("abc", StringUtils.join("a", "b", "c"));
- assertEquals("a", StringUtils.join(null, "", "a"));
- assertNull( StringUtils.join((Object[])null));
+ assertEquals("a", StringUtils.join(null, "", "a"));
+ assertNull(StringUtils.join((Object[]) null));
}
@Test
@@ -309,12 +310,12 @@
assertEquals("", StringUtils.join(EMPTY_ARRAY_LIST));
assertEquals("", StringUtils.join(NULL_ARRAY_LIST));
assertEquals("null", StringUtils.join(NULL_TO_STRING_LIST));
- assertEquals("abc", StringUtils.join(new String[] {"a", "b", "c"}));
- assertEquals("a", StringUtils.join(new String[] {null, "a", ""}));
+ assertEquals("abc", StringUtils.join(new String[]{"a", "b", "c"}));
+ assertEquals("a", StringUtils.join(new String[]{null, "a", ""}));
assertEquals("foo", StringUtils.join(MIXED_ARRAY_LIST));
assertEquals("foo2", StringUtils.join(MIXED_TYPE_LIST));
}
-
+
@Test
public void testJoin_ArrayCharSeparator() {
assertNull(StringUtils.join((Object[]) null, ','));
@@ -323,71 +324,71 @@
assertEquals(";;foo", StringUtils.join(MIXED_ARRAY_LIST, SEPARATOR_CHAR));
assertEquals("foo;2", StringUtils.join(MIXED_TYPE_LIST, SEPARATOR_CHAR));
- assertEquals("/", StringUtils.join(MIXED_ARRAY_LIST, '/', 0, MIXED_ARRAY_LIST.length-1));
+ assertEquals("/", StringUtils.join(MIXED_ARRAY_LIST, '/', 0, MIXED_ARRAY_LIST.length - 1));
assertEquals("foo", StringUtils.join(MIXED_TYPE_LIST, '/', 0, 1));
- assertEquals("null", StringUtils.join(NULL_TO_STRING_LIST,'/', 0, 1));
+ assertEquals("null", StringUtils.join(NULL_TO_STRING_LIST, '/', 0, 1));
assertEquals("foo/2", StringUtils.join(MIXED_TYPE_LIST, '/', 0, 2));
assertEquals("2", StringUtils.join(MIXED_TYPE_LIST, '/', 1, 2));
assertEquals("", StringUtils.join(MIXED_TYPE_LIST, '/', 2, 1));
}
-
+
@Test
public void testJoin_ArrayOfChars() {
assertNull(StringUtils.join((char[]) null, ','));
assertEquals("1;2", StringUtils.join(CHAR_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2", StringUtils.join(CHAR_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayOfBytes() {
assertNull(StringUtils.join((byte[]) null, ','));
assertEquals("1;2", StringUtils.join(BYTE_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2", StringUtils.join(BYTE_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayOfInts() {
assertNull(StringUtils.join((int[]) null, ','));
assertEquals("1;2", StringUtils.join(INT_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2", StringUtils.join(INT_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayOfLongs() {
assertNull(StringUtils.join((long[]) null, ','));
assertEquals("1;2", StringUtils.join(LONG_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2", StringUtils.join(LONG_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayOfFloats() {
assertNull(StringUtils.join((float[]) null, ','));
assertEquals("1.0;2.0", StringUtils.join(FLOAT_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2.0", StringUtils.join(FLOAT_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayOfDoubles() {
assertNull(StringUtils.join((double[]) null, ','));
assertEquals("1.0;2.0", StringUtils.join(DOUBLE_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2.0", StringUtils.join(DOUBLE_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayOfShorts() {
assertNull(StringUtils.join((short[]) null, ','));
assertEquals("1;2", StringUtils.join(SHORT_PRIM_LIST, SEPARATOR_CHAR));
assertEquals("2", StringUtils.join(SHORT_PRIM_LIST, SEPARATOR_CHAR, 1, 2));
}
-
+
@Test
public void testJoin_ArrayString() {
assertNull(StringUtils.join((Object[]) null, null));
assertEquals(TEXT_LIST_NOSEP, StringUtils.join(ARRAY_LIST, null));
assertEquals(TEXT_LIST_NOSEP, StringUtils.join(ARRAY_LIST, ""));
-
+
assertEquals("", StringUtils.join(NULL_ARRAY_LIST, null));
-
+
assertEquals("", StringUtils.join(EMPTY_ARRAY_LIST, null));
assertEquals("", StringUtils.join(EMPTY_ARRAY_LIST, ""));
assertEquals("", StringUtils.join(EMPTY_ARRAY_LIST, SEPARATOR));
@@ -396,14 +397,14 @@
assertEquals(",,foo", StringUtils.join(MIXED_ARRAY_LIST, SEPARATOR));
assertEquals("foo,2", StringUtils.join(MIXED_TYPE_LIST, SEPARATOR));
- assertEquals("/", StringUtils.join(MIXED_ARRAY_LIST, "/", 0, MIXED_ARRAY_LIST.length-1));
- assertEquals("", StringUtils.join(MIXED_ARRAY_LIST, "", 0, MIXED_ARRAY_LIST.length-1));
+ assertEquals("/", StringUtils.join(MIXED_ARRAY_LIST, "/", 0, MIXED_ARRAY_LIST.length - 1));
+ assertEquals("", StringUtils.join(MIXED_ARRAY_LIST, "", 0, MIXED_ARRAY_LIST.length - 1));
assertEquals("foo", StringUtils.join(MIXED_TYPE_LIST, "/", 0, 1));
assertEquals("foo/2", StringUtils.join(MIXED_TYPE_LIST, "/", 0, 2));
assertEquals("2", StringUtils.join(MIXED_TYPE_LIST, "/", 1, 2));
assertEquals("", StringUtils.join(MIXED_TYPE_LIST, "/", 2, 1));
}
-
+
@Test
public void testJoin_IteratorChar() {
assertNull(StringUtils.join((Iterator<?>) null, ','));
@@ -412,7 +413,7 @@
assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST).iterator(), SEPARATOR_CHAR));
assertEquals("foo", StringUtils.join(Collections.singleton("foo").iterator(), 'x'));
}
-
+
@Test
public void testJoin_IteratorString() {
assertNull(StringUtils.join((Iterator<?>) null, null));
@@ -422,11 +423,11 @@
assertEquals("foo", StringUtils.join(Collections.singleton("foo").iterator(), null));
assertEquals("", StringUtils.join(Arrays.asList(NULL_ARRAY_LIST).iterator(), null));
-
+
assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST).iterator(), null));
assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST).iterator(), ""));
assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST).iterator(), SEPARATOR));
-
+
assertEquals(TEXT_LIST, StringUtils.join(Arrays.asList(ARRAY_LIST).iterator(), SEPARATOR));
assertNull(StringUtils.join(Arrays.asList(NULL_TO_STRING_LIST).iterator(), SEPARATOR));
@@ -480,26 +481,26 @@
public void testSplit_String() {
assertNull(StringUtils.split(null));
assertEquals(0, StringUtils.split("").length);
-
+
String str = "a b .c";
String[] res = StringUtils.split(str);
assertEquals(3, res.length);
assertEquals("a", res[0]);
assertEquals("b", res[1]);
assertEquals(".c", res[2]);
-
+
str = " a ";
res = StringUtils.split(str);
assertEquals(1, res.length);
assertEquals("a", res[0]);
-
+
str = "a" + WHITESPACE + "b" + NON_WHITESPACE + "c";
res = StringUtils.split(str);
assertEquals(2, res.length);
assertEquals("a", res[0]);
- assertEquals("b" + NON_WHITESPACE + "c", res[1]);
+ assertEquals("b" + NON_WHITESPACE + "c", res[1]);
}
-
+
@Test
public void testSplit_StringChar() {
assertNull(StringUtils.split(null, '.'));
@@ -511,28 +512,28 @@
assertEquals("a", res[0]);
assertEquals("b", res[1]);
assertEquals(" c", res[2]);
-
+
str = ".a.";
res = StringUtils.split(str, '.');
assertEquals(1, res.length);
assertEquals("a", res[0]);
-
+
str = "a b c";
- res = StringUtils.split(str,' ');
+ res = StringUtils.split(str, ' ');
assertEquals(3, res.length);
assertEquals("a", res[0]);
assertEquals("b", res[1]);
assertEquals("c", res[2]);
}
-
+
@Test
public void testSplit_StringString_StringStringInt() {
assertNull(StringUtils.split(null, "."));
assertNull(StringUtils.split(null, ".", 3));
-
+
assertEquals(0, StringUtils.split("", ".").length);
assertEquals(0, StringUtils.split("", ".", 3).length);
-
+
innerTestSplit('.', ".", ' ');
innerTestSplit('.', ".", ',');
innerTestSplit('.', ".,", 'x');
@@ -542,7 +543,7 @@
innerTestSplit(WHITESPACE.charAt(i), String.valueOf(WHITESPACE.charAt(i)), NON_WHITESPACE.charAt(j));
}
}
-
+
String[] results;
final String[] expectedResults = {"ab", "de fg"};
results = StringUtils.split("ab de fg", null, 2);
@@ -550,19 +551,19 @@
for (int i = 0; i < expectedResults.length; i++) {
assertEquals(expectedResults[i], results[i]);
}
-
+
final String[] expectedResults2 = {"ab", "cd:ef"};
- results = StringUtils.split("ab:cd:ef",":", 2);
+ results = StringUtils.split("ab:cd:ef", ":", 2);
assertEquals(expectedResults2.length, results.length);
for (int i = 0; i < expectedResults2.length; i++) {
assertEquals(expectedResults2[i], results[i]);
}
}
-
+
private void innerTestSplit(final char separator, final String sepStr, final char noMatch) {
final String msg = "Failed on separator hex(" + Integer.toHexString(separator) +
- "), noMatch hex(" + Integer.toHexString(noMatch) + "), sepStr(" + sepStr + ")";
-
+ "), noMatch hex(" + Integer.toHexString(noMatch) + "), sepStr(" + sepStr + ")";
+
final String str = "a" + separator + "b" + separator + separator + noMatch + "c";
String[] res;
// (str, sepStr)
@@ -571,7 +572,7 @@
assertEquals(msg, "a", res[0]);
assertEquals(msg, "b", res[1]);
assertEquals(msg, noMatch + "c", res[2]);
-
+
final String str2 = separator + "a" + separator;
res = StringUtils.split(str2, sepStr);
assertEquals(msg, 1, res.length);
@@ -582,17 +583,17 @@
assertEquals(msg, "a", res[0]);
assertEquals(msg, "b", res[1]);
assertEquals(msg, noMatch + "c", res[2]);
-
+
res = StringUtils.split(str, sepStr, 0);
assertEquals(msg, 3, res.length);
assertEquals(msg, "a", res[0]);
assertEquals(msg, "b", res[1]);
assertEquals(msg, noMatch + "c", res[2]);
-
+
res = StringUtils.split(str, sepStr, 1);
assertEquals(msg, 1, res.length);
assertEquals(msg, str, res[0]);
-
+
res = StringUtils.split(str, sepStr, 2);
assertEquals(msg, 2, res.length);
assertEquals(msg, "a", res[0]);
@@ -601,142 +602,142 @@
@Test
public void testSplitByWholeString_StringStringBoolean() {
- assertArrayEquals( null, StringUtils.splitByWholeSeparator( null, "." ) ) ;
+ assertArrayEquals(null, StringUtils.splitByWholeSeparator(null, "."));
- assertEquals( 0, StringUtils.splitByWholeSeparator( "", "." ).length ) ;
+ assertEquals(0, StringUtils.splitByWholeSeparator("", ".").length);
- final String stringToSplitOnNulls = "ab de fg" ;
- final String[] splitOnNullExpectedResults = { "ab", "de", "fg" } ;
+ final String stringToSplitOnNulls = "ab de fg";
+ final String[] splitOnNullExpectedResults = {"ab", "de", "fg"};
- final 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] ) ;
+ final 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]);
}
- final String stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiously" ;
+ final String stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiously";
- final String[] splitOnStringExpectedResults = { "abstemiously", "abstemiously" } ;
- final String[] splitOnStringResults = StringUtils.splitByWholeSeparator( stringToSplitOnCharactersAndString, "aeiouy" ) ;
- assertEquals( splitOnStringExpectedResults.length, splitOnStringResults.length ) ;
- for ( int i = 0 ; i < splitOnStringExpectedResults.length ; i+= 1 ) {
- assertEquals( splitOnStringExpectedResults[i], splitOnStringResults[i] ) ;
+ final String[] splitOnStringExpectedResults = {"abstemiously", "abstemiously"};
+ final String[] splitOnStringResults = StringUtils.splitByWholeSeparator(stringToSplitOnCharactersAndString, "aeiouy");
+ assertEquals(splitOnStringExpectedResults.length, splitOnStringResults.length);
+ for (int i = 0; i < splitOnStringExpectedResults.length; i += 1) {
+ assertEquals(splitOnStringExpectedResults[i], splitOnStringResults[i]);
}
final String[] splitWithMultipleSeparatorExpectedResults = {"ab", "cd", "ef"};
final String[] splitWithMultipleSeparator = StringUtils.splitByWholeSeparator("ab:cd::ef", ":");
- assertEquals( splitWithMultipleSeparatorExpectedResults.length, splitWithMultipleSeparator.length );
- for( int i = 0; i < splitWithMultipleSeparatorExpectedResults.length ; i++ ) {
- assertEquals( splitWithMultipleSeparatorExpectedResults[i], splitWithMultipleSeparator[i] ) ;
+ assertEquals(splitWithMultipleSeparatorExpectedResults.length, splitWithMultipleSeparator.length);
+ for (int i = 0; i < splitWithMultipleSeparatorExpectedResults.length; i++) {
+ assertEquals(splitWithMultipleSeparatorExpectedResults[i], splitWithMultipleSeparator[i]);
}
}
@Test
public void testSplitByWholeString_StringStringBooleanInt() {
- assertArrayEquals( null, StringUtils.splitByWholeSeparator( null, ".", 3 ) ) ;
+ assertArrayEquals(null, StringUtils.splitByWholeSeparator(null, ".", 3));
- assertEquals( 0, StringUtils.splitByWholeSeparator( "", ".", 3 ).length ) ;
+ assertEquals(0, StringUtils.splitByWholeSeparator("", ".", 3).length);
- final String stringToSplitOnNulls = "ab de fg" ;
- final String[] splitOnNullExpectedResults = { "ab", "de fg" } ;
+ final String stringToSplitOnNulls = "ab de fg";
+ final String[] splitOnNullExpectedResults = {"ab", "de fg"};
//String[] splitOnNullExpectedResults = { "ab", "de" } ;
- final String[] splitOnNullResults = StringUtils.splitByWholeSeparator( stringToSplitOnNulls, null, 2 ) ;
- assertEquals( splitOnNullExpectedResults.length, splitOnNullResults.length ) ;
- for ( int i = 0 ; i < splitOnNullExpectedResults.length ; i+= 1 ) {
- assertEquals( splitOnNullExpectedResults[i], splitOnNullResults[i] ) ;
+ final String[] splitOnNullResults = StringUtils.splitByWholeSeparator(stringToSplitOnNulls, null, 2);
+ assertEquals(splitOnNullExpectedResults.length, splitOnNullResults.length);
+ for (int i = 0; i < splitOnNullExpectedResults.length; i += 1) {
+ assertEquals(splitOnNullExpectedResults[i], splitOnNullResults[i]);
}
- final String stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiouslyaeiouyabstemiously" ;
+ final String stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiouslyaeiouyabstemiously";
- final String[] splitOnStringExpectedResults = { "abstemiously", "abstemiouslyaeiouyabstemiously" } ;
+ final String[] splitOnStringExpectedResults = {"abstemiously", "abstemiouslyaeiouyabstemiously"};
//String[] splitOnStringExpectedResults = { "abstemiously", "abstemiously" } ;
- final String[] splitOnStringResults = StringUtils.splitByWholeSeparator( stringToSplitOnCharactersAndString, "aeiouy", 2 ) ;
- assertEquals( splitOnStringExpectedResults.length, splitOnStringResults.length ) ;
- for ( int i = 0 ; i < splitOnStringExpectedResults.length ; i++ ) {
- assertEquals( splitOnStringExpectedResults[i], splitOnStringResults[i] ) ;
+ final String[] splitOnStringResults = StringUtils.splitByWholeSeparator(stringToSplitOnCharactersAndString, "aeiouy", 2);
+ assertEquals(splitOnStringExpectedResults.length, splitOnStringResults.length);
+ for (int i = 0; i < splitOnStringExpectedResults.length; i++) {
+ assertEquals(splitOnStringExpectedResults[i], splitOnStringResults[i]);
}
}
@Test
public void testSplitByWholeSeparatorPreserveAllTokens_StringStringInt() {
- assertArrayEquals( null, StringUtils.splitByWholeSeparatorPreserveAllTokens( null, ".", -1 ) ) ;
+ assertArrayEquals(null, StringUtils.splitByWholeSeparatorPreserveAllTokens(null, ".", -1));
- assertEquals( 0, StringUtils.splitByWholeSeparatorPreserveAllTokens( "", ".", -1 ).length ) ;
+ assertEquals(0, StringUtils.splitByWholeSeparatorPreserveAllTokens("", ".", -1).length);
// test whitespace
- String input = "ab de fg" ;
- String[] expected = new String[] { "ab", "", "", "de", "fg" } ;
+ String input = "ab de fg";
+ String[] expected = new String[]{"ab", "", "", "de", "fg"};
- String[] actual = StringUtils.splitByWholeSeparatorPreserveAllTokens( input, null, -1 ) ;
- assertEquals( expected.length, actual.length ) ;
- for ( int i = 0 ; i < actual.length ; i+= 1 ) {
- assertEquals( expected[i], actual[i] );
+ String[] actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, null, -1);
+ assertEquals(expected.length, actual.length);
+ for (int i = 0; i < actual.length; i += 1) {
+ assertEquals(expected[i], actual[i]);
}
// test delimiter singlechar
input = "1::2:::3::::4";
- expected = new String[] { "1", "", "2", "", "", "3", "", "", "", "4" };
+ expected = new String[]{"1", "", "2", "", "", "3", "", "", "", "4"};
- actual = StringUtils.splitByWholeSeparatorPreserveAllTokens( input, ":", -1 ) ;
- assertEquals( expected.length, actual.length ) ;
- for ( int i = 0 ; i < actual.length ; i+= 1 ) {
- assertEquals( expected[i], actual[i] );
+ actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, ":", -1);
+ assertEquals(expected.length, actual.length);
+ for (int i = 0; i < actual.length; i += 1) {
+ assertEquals(expected[i], actual[i]);
}
// test delimiter multichar
input = "1::2:::3::::4";
- expected = new String[] { "1", "2", ":3", "", "4" };
+ expected = new String[]{"1", "2", ":3", "", "4"};
- actual = StringUtils.splitByWholeSeparatorPreserveAllTokens( input, "::", -1 ) ;
- assertEquals( expected.length, actual.length ) ;
- for ( int i = 0 ; i < actual.length ; i+= 1 ) {
- assertEquals( expected[i], actual[i] );
+ actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, "::", -1);
+ assertEquals(expected.length, actual.length);
+ for (int i = 0; i < actual.length; i += 1) {
+ assertEquals(expected[i], actual[i]);
}
// test delimiter char with max
input = "1::2::3:4";
- expected = new String[] { "1", "", "2", ":3:4" };
+ expected = new String[]{"1", "", "2", ":3:4"};
- actual = StringUtils.splitByWholeSeparatorPreserveAllTokens( input, ":", 4 ) ;
- assertEquals( expected.length, actual.length ) ;
- for ( int i = 0 ; i < actual.length ; i+= 1 ) {
- assertEquals( expected[i], actual[i] );
+ actual = StringUtils.splitByWholeSeparatorPreserveAllTokens(input, ":", 4);
+ assertEquals(expected.length, actual.length);
+ for (int i = 0; i < actual.length; i += 1) {
+ assertEquals(expected[i], actual[i]);
}
}
-
+
@Test
public void testSplitPreserveAllTokens_String() {
assertNull(StringUtils.splitPreserveAllTokens(null));
assertEquals(0, StringUtils.splitPreserveAllTokens("").length);
-
+
String str = "abc def";
String[] res = StringUtils.splitPreserveAllTokens(str);
assertEquals(2, res.length);
assertEquals("abc", res[0]);
assertEquals("def", res[1]);
-
+
str = "abc def";
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(3, res.length);
assertEquals("abc", res[0]);
assertEquals("", res[1]);
assertEquals("def", res[2]);
-
+
str = " abc ";
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(3, res.length);
assertEquals("", res[0]);
assertEquals("abc", res[1]);
assertEquals("", res[2]);
-
+
str = "a b .c";
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(3, res.length);
assertEquals("a", res[0]);
assertEquals("b", res[1]);
assertEquals(".c", res[2]);
-
+
str = " a b .c";
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(4, res.length);
@@ -744,7 +745,7 @@
assertEquals("a", res[1]);
assertEquals("b", res[2]);
assertEquals(".c", res[3]);
-
+
str = "a b .c";
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(5, res.length);
@@ -753,7 +754,7 @@
assertEquals("b", res[2]);
assertEquals("", res[3]);
assertEquals(".c", res[4]);
-
+
str = " a ";
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(4, res.length);
@@ -774,13 +775,12 @@
res = StringUtils.splitPreserveAllTokens(str);
assertEquals(WHITESPACE.length() + 1, res.length);
assertEquals("a", res[0]);
- for(int i = 1; i < WHITESPACE.length()-1; i++)
- {
- assertEquals("", res[i]);
+ for (int i = 1; i < WHITESPACE.length() - 1; i++) {
+ assertEquals("", res[i]);
}
- assertEquals("b" + NON_WHITESPACE + "c", res[WHITESPACE.length()]);
+ assertEquals("b" + NON_WHITESPACE + "c", res[WHITESPACE.length()]);
}
-
+
@Test
public void testSplitPreserveAllTokens_StringChar() {
assertNull(StringUtils.splitPreserveAllTokens(null, '.'));
@@ -792,7 +792,7 @@
assertEquals("a", res[0]);
assertEquals("b", res[1]);
assertEquals(" c", res[2]);
-
+
str = "a.b.. c";
res = StringUtils.splitPreserveAllTokens(str, '.');
assertEquals(4, res.length);
@@ -807,7 +807,7 @@
assertEquals("", res[0]);
assertEquals("a", res[1]);
assertEquals("", res[2]);
-
+
str = ".a..";
res = StringUtils.splitPreserveAllTokens(str, '.');
assertEquals(4, res.length);
@@ -815,7 +815,7 @@
assertEquals("a", res[1]);
assertEquals("", res[2]);
assertEquals("", res[3]);
-
+
str = "..a.";
res = StringUtils.splitPreserveAllTokens(str, '.');
assertEquals(4, res.length);
@@ -823,32 +823,32 @@
assertEquals("", res[1]);
assertEquals("a", res[2]);
assertEquals("", res[3]);
-
+
str = "..a";
res = StringUtils.splitPreserveAllTokens(str, '.');
assertEquals(3, res.length);
assertEquals("", res[0]);
assertEquals("", res[1]);
assertEquals("a", res[2]);
-
+
str = "a b c";
- res = StringUtils.splitPreserveAllTokens(str,' ');
+ res = StringUtils.splitPreserveAllTokens(str, ' ');
assertEquals(3, res.length);
assertEquals("a", res[0]);
assertEquals("b", res[1]);
assertEquals("c", res[2]);
str = "a b c";
- res = StringUtils.splitPreserveAllTokens(str,' ');
+ res = StringUtils.splitPreserveAllTokens(str, ' ');
assertEquals(5, res.length);
assertEquals("a", res[0]);
assertEquals("", res[1]);
assertEquals("b", res[2]);
assertEquals("", res[3]);
assertEquals("c", res[4]);
-
+
str = " a b c";
- res = StringUtils.splitPreserveAllTokens(str,' ');
+ res = StringUtils.splitPreserveAllTokens(str, ' ');
assertEquals(4, res.length);
assertEquals("", res[0]);
assertEquals("a", res[1]);
@@ -856,7 +856,7 @@
assertEquals("c", res[3]);
str = " a b c";
- res = StringUtils.splitPreserveAllTokens(str,' ');
+ res = StringUtils.splitPreserveAllTokens(str, ' ');
assertEquals(5, res.length);
assertEquals("", res[0]);
assertEquals("", res[1]);
@@ -865,7 +865,7 @@
assertEquals("c", res[4]);
str = "a b c ";
- res = StringUtils.splitPreserveAllTokens(str,' ');
+ res = StringUtils.splitPreserveAllTokens(str, ' ');
assertEquals(4, res.length);
assertEquals("a", res[0]);
assertEquals("b", res[1]);
@@ -873,7 +873,7 @@
assertEquals("", res[3]);
str = "a b c ";
- res = StringUtils.splitPreserveAllTokens(str,' ');
+ res = StringUtils.splitPreserveAllTokens(str, ' ');
assertEquals(5, res.length);
assertEquals("a", res[0]);
assertEquals("b", res[1]);
@@ -883,24 +883,24 @@
// Match example in javadoc
{
- String[] results;
- final String[] expectedResults = {"a", "", "b", "c"};
- results = StringUtils.splitPreserveAllTokens("a..b.c",'.');
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"a", "", "b", "c"};
+ results = StringUtils.splitPreserveAllTokens("a..b.c", '.');
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
}
-
+
@Test
public void testSplitPreserveAllTokens_StringString_StringStringInt() {
assertNull(StringUtils.splitPreserveAllTokens(null, "."));
assertNull(StringUtils.splitPreserveAllTokens(null, ".", 3));
-
+
assertEquals(0, StringUtils.splitPreserveAllTokens("", ".").length);
assertEquals(0, StringUtils.splitPreserveAllTokens("", ".", 3).length);
-
+
innerTestSplitPreserveAllTokens('.', ".", ' ');
innerTestSplitPreserveAllTokens('.', ".", ',');
innerTestSplitPreserveAllTokens('.', ".,", 'x');
@@ -912,121 +912,121 @@
}
{
- String[] results;
- final String[] expectedResults = {"ab", "de fg"};
- results = StringUtils.splitPreserveAllTokens("ab de fg", null, 2);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", "de fg"};
+ results = StringUtils.splitPreserveAllTokens("ab de fg", null, 2);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
{
- String[] results;
- final String[] expectedResults = {"ab", " de fg"};
- results = StringUtils.splitPreserveAllTokens("ab de fg", null, 2);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
- }
-
- {
- String[] results;
- final String[] expectedResults = {"ab", "::de:fg"};
- results = StringUtils.splitPreserveAllTokens("ab:::de:fg", ":", 2);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
- }
-
- {
- String[] results;
- final String[] expectedResults = {"ab", "", " de fg"};
- results = StringUtils.splitPreserveAllTokens("ab de fg", null, 3);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
- }
-
- {
- String[] results;
- final String[] expectedResults = {"ab", "", "", "de fg"};
- results = StringUtils.splitPreserveAllTokens("ab de fg", null, 4);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", " de fg"};
+ results = StringUtils.splitPreserveAllTokens("ab de fg", null, 2);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
{
- final String[] expectedResults = {"ab", "cd:ef"};
- String[] results;
- results = StringUtils.splitPreserveAllTokens("ab:cd:ef",":", 2);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", "::de:fg"};
+ results = StringUtils.splitPreserveAllTokens("ab:::de:fg", ":", 2);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
{
- String[] results;
- final String[] expectedResults = {"ab", ":cd:ef"};
- results = StringUtils.splitPreserveAllTokens("ab::cd:ef",":", 2);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", "", " de fg"};
+ results = StringUtils.splitPreserveAllTokens("ab de fg", null, 3);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
{
- String[] results;
- final String[] expectedResults = {"ab", "", ":cd:ef"};
- results = StringUtils.splitPreserveAllTokens("ab:::cd:ef",":", 3);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", "", "", "de fg"};
+ results = StringUtils.splitPreserveAllTokens("ab de fg", null, 4);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
{
- String[] results;
- final String[] expectedResults = {"ab", "", "", "cd:ef"};
- results = StringUtils.splitPreserveAllTokens("ab:::cd:ef",":", 4);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ final String[] expectedResults = {"ab", "cd:ef"};
+ String[] results;
+ results = StringUtils.splitPreserveAllTokens("ab:cd:ef", ":", 2);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
{
- String[] results;
- final String[] expectedResults = {"", "ab", "", "", "cd:ef"};
- results = StringUtils.splitPreserveAllTokens(":ab:::cd:ef",":", 5);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", ":cd:ef"};
+ results = StringUtils.splitPreserveAllTokens("ab::cd:ef", ":", 2);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
-
+
{
- String[] results;
- final String[] expectedResults = {"", "", "ab", "", "", "cd:ef"};
- results = StringUtils.splitPreserveAllTokens("::ab:::cd:ef",":", 6);
- assertEquals(expectedResults.length, results.length);
- for (int i = 0; i < expectedResults.length; i++) {
- assertEquals(expectedResults[i], results[i]);
- }
+ String[] results;
+ final String[] expectedResults = {"ab", "", ":cd:ef"};
+ results = StringUtils.splitPreserveAllTokens("ab:::cd:ef", ":", 3);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
}
-
+
+ {
+ String[] results;
+ final String[] expectedResults = {"ab", "", "", "cd:ef"};
+ results = StringUtils.splitPreserveAllTokens("ab:::cd:ef", ":", 4);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
+ }
+
+ {
+ String[] results;
+ final String[] expectedResults = {"", "ab", "", "", "cd:ef"};
+ results = StringUtils.splitPreserveAllTokens(":ab:::cd:ef", ":", 5);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
+ }
+
+ {
+ String[] results;
+ final String[] expectedResults = {"", "", "ab", "", "", "cd:ef"};
+ results = StringUtils.splitPreserveAllTokens("::ab:::cd:ef", ":", 6);
+ assertEquals(expectedResults.length, results.length);
+ for (int i = 0; i < expectedResults.length; i++) {
+ assertEquals(expectedResults[i], results[i]);
+ }
+ }
+
}
-
+
private void innerTestSplitPreserveAllTokens(final char separator, final String sepStr, final char noMatch) {
final String msg = "Failed on separator hex(" + Integer.toHexString(separator) +
- "), noMatch hex(" + Integer.toHexString(noMatch) + "), sepStr(" + sepStr + ")";
-
+ "), noMatch hex(" + Integer.toHexString(noMatch) + "), sepStr(" + sepStr + ")";
+
final String str = "a" + separator + "b" + separator + separator + noMatch + "c";
String[] res;
// (str, sepStr)
@@ -1036,7 +1036,7 @@
assertEquals(msg, "b", res[1]);
assertEquals(msg, "", res[2]);
assertEquals(msg, noMatch + "c", res[3]);
-
+
final String str2 = separator + "a" + separator;
res = StringUtils.splitPreserveAllTokens(str2, sepStr);
assertEquals(msg, 3, res.length);
@@ -1050,18 +1050,18 @@
assertEquals(msg, "b", res[1]);
assertEquals(msg, "", res[2]);
assertEquals(msg, noMatch + "c", res[3]);
-
+
res = StringUtils.splitPreserveAllTokens(str, sepStr, 0);
assertEquals(msg, 4, res.length);
assertEquals(msg, "a", res[0]);
assertEquals(msg, "b", res[1]);
assertEquals(msg, "", res[2]);
assertEquals(msg, noMatch + "c", res[3]);
-
+
res = StringUtils.splitPreserveAllTokens(str, sepStr, 1);
assertEquals(msg, 1, res.length);
assertEquals(msg, str, res[0]);
-
+
res = StringUtils.splitPreserveAllTokens(str, sepStr, 2);
assertEquals(msg, 2, res.length);
assertEquals(msg, "a", res[0]);
@@ -1072,53 +1072,53 @@
public void testSplitByCharacterType() {
assertNull(StringUtils.splitByCharacterType(null));
assertEquals(0, StringUtils.splitByCharacterType("").length);
-
- assertTrue(ArrayUtils.isEquals(new String[] { "ab", " ", "de", " ",
- "fg" }, StringUtils.splitByCharacterType("ab de fg")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "ab", " ", "de", " ",
- "fg" }, StringUtils.splitByCharacterType("ab de fg")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "ab", ":", "cd", ":",
- "ef" }, StringUtils.splitByCharacterType("ab:cd:ef")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "number", "5" },
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"ab", " ", "de", " ",
+ "fg"}, StringUtils.splitByCharacterType("ab de fg")));
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"ab", " ", "de", " ",
+ "fg"}, StringUtils.splitByCharacterType("ab de fg")));
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"ab", ":", "cd", ":",
+ "ef"}, StringUtils.splitByCharacterType("ab:cd:ef")));
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"number", "5"},
StringUtils.splitByCharacterType("number5")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "foo", "B", "ar" },
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"foo", "B", "ar"},
StringUtils.splitByCharacterType("fooBar")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "foo", "200", "B", "ar" },
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"foo", "200", "B", "ar"},
StringUtils.splitByCharacterType("foo200Bar")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "ASFR", "ules" },
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"ASFR", "ules"},
StringUtils.splitByCharacterType("ASFRules")));
}
-
+
@Test
public void testSplitByCharacterTypeCamelCase() {
assertNull(StringUtils.splitByCharacterTypeCamelCase(null));
assertEquals(0, StringUtils.splitByCharacterTypeCamelCase("").length);
- assertTrue(ArrayUtils.isEquals(new String[] { "ab", " ", "de", " ",
- "fg" }, StringUtils.splitByCharacterTypeCamelCase("ab de fg")));
+ assertTrue(ArrayUtils.isEquals(new String[]{"ab", " ", "de", " ",
+ "fg"}, StringUtils.splitByCharacterTypeCamelCase("ab de fg")));
- assertTrue(ArrayUtils.isEquals(new String[] { "ab", " ", "de", " ",
- "fg" }, StringUtils.splitByCharacterTypeCamelCase("ab de fg")));
+ assertTrue(ArrayUtils.isEquals(new String[]{"ab", " ", "de", " ",
+ "fg"}, StringUtils.splitByCharacterTypeCamelCase("ab de fg")));
- assertTrue(ArrayUtils.isEquals(new String[] { "ab", ":", "cd", ":",
- "ef" }, StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef")));
-
- assertTrue(ArrayUtils.isEquals(new String[] { "number", "5" },
+ assertTrue(ArrayUtils.isEquals(new String[]{"ab", ":", "cd", ":",
+ "ef"}, StringUtils.splitByCharacterTypeCamelCase("ab:cd:ef")));
+
+ assertTrue(ArrayUtils.isEquals(new String[]{"number", "5"},
StringUtils.splitByCharacterTypeCamelCase("number5")));
- assertTrue(ArrayUtils.isEquals(new String[] { "foo", "Bar" },
+ assertTrue(ArrayUtils.isEquals(new String[]{"foo", "Bar"},
StringUtils.splitByCharacterTypeCamelCase("fooBar")));
- assertTrue(ArrayUtils.isEquals(new String[] { "foo", "200", "Bar" },
+ assertTrue(ArrayUtils.isEquals(new String[]{"foo", "200", "Bar"},
StringUtils.splitByCharacterTypeCamelCase("foo200Bar")));
- assertTrue(ArrayUtils.isEquals(new String[] { "ASF", "Rules" },
+ assertTrue(ArrayUtils.isEquals(new String[]{"ASF", "Rules"},
StringUtils.splitByCharacterTypeCamelCase("ASFRules")));
}
@@ -1163,17 +1163,17 @@
assertEquals("barbarbar", StringUtils.replace("foofoofoo", "foo", "bar"));
assertEquals("farfarfar", StringUtils.replace("foofoofoo", "oo", "ar"));
}
-
+
@Test
public void testReplacePattern() {
assertEquals("X", StringUtils.replacePattern("<A>\nxy\n</A>", "<A>.*</A>", "X"));
}
-
+
@Test
public void testRemovePattern() {
assertEquals("", StringUtils.removePattern("<A>x\\ny</A>", "<A>.*</A>"));
}
-
+
@Test
public void testReplace_StringStringStringInt() {
assertNull(StringUtils.replace(null, null, null, 2));
@@ -1185,21 +1185,21 @@
assertEquals("", StringUtils.replace("", null, "any", 2));
assertEquals("", StringUtils.replace("", "any", null, 2));
assertEquals("", StringUtils.replace("", "any", "any", 2));
-
- final String str = new String(new char[] {'o', 'o', 'f', 'o', 'o'});
+
+ final String str = new String(new char[]{'o', 'o', 'f', 'o', 'o'});
assertSame(str, StringUtils.replace(str, "x", "", -1));
-
+
assertEquals("f", StringUtils.replace("oofoo", "o", "", -1));
assertEquals("oofoo", StringUtils.replace("oofoo", "o", "", 0));
assertEquals("ofoo", StringUtils.replace("oofoo", "o", "", 1));
assertEquals("foo", StringUtils.replace("oofoo", "o", "", 2));
assertEquals("fo", StringUtils.replace("oofoo", "o", "", 3));
assertEquals("f", StringUtils.replace("oofoo", "o", "", 4));
-
+
assertEquals("f", StringUtils.replace("oofoo", "o", "", -5));
assertEquals("f", StringUtils.replace("oofoo", "o", "", 1000));
}
-
+
@Test
public void testReplaceOnce_StringStringString() {
assertNull(StringUtils.replaceOnce(null, null, null));
@@ -1227,32 +1227,32 @@
public void testReplace_StringStringArrayStringArray() {
//JAVADOC TESTS START
assertNull(StringUtils.replaceEach(null, new String[]{"a"}, new String[]{"b"}));
- assertEquals(StringUtils.replaceEach("", new String[]{"a"}, new String[]{"b"}),"");
- assertEquals(StringUtils.replaceEach("aba", null, null),"aba");
- assertEquals(StringUtils.replaceEach("aba", new String[0], null),"aba");
- assertEquals(StringUtils.replaceEach("aba", null, new String[0]),"aba");
- assertEquals(StringUtils.replaceEach("aba", new String[]{"a"}, null),"aba");
+ assertEquals(StringUtils.replaceEach("", new String[]{"a"}, new String[]{"b"}), "");
+ assertEquals(StringUtils.replaceEach("aba", null, null), "aba");
+ assertEquals(StringUtils.replaceEach("aba", new String[0], null), "aba");
+ assertEquals(StringUtils.replaceEach("aba", null, new String[0]), "aba");
+ assertEquals(StringUtils.replaceEach("aba", new String[]{"a"}, null), "aba");
- assertEquals(StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}),"b");
- assertEquals(StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}),"aba");
- assertEquals(StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}),"wcte");
- assertEquals(StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}),"dcte");
+ assertEquals(StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{""}), "b");
+ assertEquals(StringUtils.replaceEach("aba", new String[]{null}, new String[]{"a"}), "aba");
+ assertEquals(StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}), "wcte");
+ assertEquals(StringUtils.replaceEach("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}), "dcte");
//JAVADOC TESTS END
assertEquals("bcc", StringUtils.replaceEach("abc", new String[]{"a", "b"}, new String[]{"b", "c"}));
assertEquals("q651.506bera", StringUtils.replaceEach("d216.102oren",
- new String[]{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n",
- "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D",
- "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
- "U", "V", "W", "X", "Y", "Z", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
- new String[]{"n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "a",
- "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "N", "O", "P", "Q",
- "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "A", "B", "C", "D", "E", "F", "G",
- "H", "I", "J", "K", "L", "M", "5", "6", "7", "8", "9", "1", "2", "3", "4"}));
+ new String[]{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n",
+ "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D",
+ "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
+ "U", "V", "W", "X", "Y", "Z", "1", "2", "3", "4", "5", "6", "7", "8", "9"},
+ new String[]{"n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "a",
+ "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "N", "O", "P", "Q",
+ "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "A", "B", "C", "D", "E", "F", "G",
+ "H", "I", "J", "K", "L", "M", "5", "6", "7", "8", "9", "1", "2", "3", "4"}));
// Test null safety inside arrays - LANG-552
- assertEquals(StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{null}),"aba");
- assertEquals(StringUtils.replaceEach("aba", new String[]{"a", "b"}, new String[]{"c", null}),"cbc");
+ assertEquals(StringUtils.replaceEach("aba", new String[]{"a"}, new String[]{null}), "aba");
+ assertEquals(StringUtils.replaceEach("aba", new String[]{"a", "b"}, new String[]{"c", null}), "cbc");
}
/**
@@ -1262,25 +1262,26 @@
public void testReplace_StringStringArrayStringArrayBoolean() {
//JAVADOC TESTS START
assertNull(StringUtils.replaceEachRepeatedly(null, new String[]{"a"}, new String[]{"b"}));
- assertEquals(StringUtils.replaceEachRepeatedly("", new String[]{"a"}, new String[]{"b"}),"");
- assertEquals(StringUtils.replaceEachRepeatedly("aba", null, null),"aba");
- assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[0], null),"aba");
- assertEquals(StringUtils.replaceEachRepeatedly("aba", null, new String[0]),"aba");
- assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[0], null),"aba");
+ assertEquals(StringUtils.replaceEachRepeatedly("", new String[]{"a"}, new String[]{"b"}), "");
+ assertEquals(StringUtils.replaceEachRepeatedly("aba", null, null), "aba");
+ assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[0], null), "aba");
+ assertEquals(StringUtils.replaceEachRepeatedly("aba", null, new String[0]), "aba");
+ assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[0], null), "aba");
- assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, new String[]{""}),"b");
- assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[]{null}, new String[]{"a"}),"aba");
- assertEquals(StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}),"wcte");
- assertEquals(StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}),"tcte");
+ assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[]{"a"}, new String[]{""}), "b");
+ assertEquals(StringUtils.replaceEachRepeatedly("aba", new String[]{null}, new String[]{"a"}), "aba");
+ assertEquals(StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"w", "t"}), "wcte");
+ assertEquals(StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "t"}), "tcte");
try {
StringUtils.replaceEachRepeatedly("abcde", new String[]{"ab", "d"}, new String[]{"d", "ab"});
fail("Should be a circular reference");
- } catch (final IllegalStateException e) {}
+ } catch (final IllegalStateException e) {
+ }
//JAVADOC TESTS END
}
-
+
@Test
public void testReplaceChars_StringCharChar() {
assertNull(StringUtils.replaceChars(null, 'b', 'z'));
@@ -1288,7 +1289,7 @@
assertEquals("azcza", StringUtils.replaceChars("abcba", 'b', 'z'));
assertEquals("abcba", StringUtils.replaceChars("abcba", 'x', 'z'));
}
-
+
@Test
public void testReplaceChars_StringStringString() {
assertNull(StringUtils.replaceChars(null, null, null));
@@ -1296,7 +1297,7 @@
assertNull(StringUtils.replaceChars(null, "a", null));
assertNull(StringUtils.replaceChars(null, null, ""));
assertNull(StringUtils.replaceChars(null, null, "x"));
-
+
assertEquals("", StringUtils.replaceChars("", null, null));
assertEquals("", StringUtils.replaceChars("", "", null));
assertEquals("", StringUtils.replaceChars("", "a", null));
@@ -1306,53 +1307,53 @@
assertEquals("abc", StringUtils.replaceChars("abc", null, null));
assertEquals("abc", StringUtils.replaceChars("abc", null, ""));
assertEquals("abc", StringUtils.replaceChars("abc", null, "x"));
-
+
assertEquals("abc", StringUtils.replaceChars("abc", "", null));
assertEquals("abc", StringUtils.replaceChars("abc", "", ""));
assertEquals("abc", StringUtils.replaceChars("abc", "", "x"));
-
+
assertEquals("ac", StringUtils.replaceChars("abc", "b", null));
assertEquals("ac", StringUtils.replaceChars("abc", "b", ""));
assertEquals("axc", StringUtils.replaceChars("abc", "b", "x"));
-
+
assertEquals("ayzya", StringUtils.replaceChars("abcba", "bc", "yz"));
assertEquals("ayya", StringUtils.replaceChars("abcba", "bc", "y"));
assertEquals("ayzya", StringUtils.replaceChars("abcba", "bc", "yzx"));
-
+
assertEquals("abcba", StringUtils.replaceChars("abcba", "z", "w"));
assertSame("abcba", StringUtils.replaceChars("abcba", "z", "w"));
-
+
// Javadoc examples:
assertEquals("jelly", StringUtils.replaceChars("hello", "ho", "jy"));
assertEquals("ayzya", StringUtils.replaceChars("abcba", "bc", "yz"));
assertEquals("ayya", StringUtils.replaceChars("abcba", "bc", "y"));
assertEquals("ayzya", StringUtils.replaceChars("abcba", "bc", "yzx"));
-
+
// From http://issues.apache.org/bugzilla/show_bug.cgi?id=25454
assertEquals("bcc", StringUtils.replaceChars("abc", "ab", "bc"));
assertEquals("q651.506bera", StringUtils.replaceChars("d216.102oren",
- "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789",
- "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM567891234"));
+ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ123456789",
+ "nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM567891234"));
}
-
+
@Test
public void testOverlay_StringStringIntInt() {
assertNull(StringUtils.overlay(null, null, 2, 4));
assertNull(StringUtils.overlay(null, null, -2, -4));
-
+
assertEquals("", StringUtils.overlay("", null, 0, 0));
assertEquals("", StringUtils.overlay("", "", 0, 0));
assertEquals("zzzz", StringUtils.overlay("", "zzzz", 0, 0));
assertEquals("zzzz", StringUtils.overlay("", "zzzz", 2, 4));
assertEquals("zzzz", StringUtils.overlay("", "zzzz", -2, -4));
-
+
assertEquals("abef", StringUtils.overlay("abcdef", null, 2, 4));
assertEquals("abef", StringUtils.overlay("abcdef", null, 4, 2));
assertEquals("abef", StringUtils.overlay("abcdef", "", 2, 4));
assertEquals("abef", StringUtils.overlay("abcdef", "", 4, 2));
assertEquals("abzzzzef", StringUtils.overlay("abcdef", "zzzz", 2, 4));
assertEquals("abzzzzef", StringUtils.overlay("abcdef", "zzzz", 4, 2));
-
+
assertEquals("zzzzef", StringUtils.overlay("abcdef", "zzzz", -1, 4));
assertEquals("zzzzef", StringUtils.overlay("abcdef", "zzzz", 4, -1));
assertEquals("zzzzabcdef", StringUtils.overlay("abcdef", "zzzz", -2, -1));
@@ -1374,7 +1375,7 @@
assertEquals("abcabcabc", StringUtils.repeat("abc", 3));
final String str = StringUtils.repeat("a", 10000); // bigger than pad limit
assertEquals(10000, str.length());
- assertTrue(StringUtils.containsOnly(str, new char[] {'a'}));
+ assertTrue(StringUtils.containsOnly(str, new char[]{'a'}));
}
@Test
@@ -1402,18 +1403,18 @@
public void testChop() {
final String[][] chopCases = {
- { FOO_UNCAP + "\r\n", FOO_UNCAP } ,
- { FOO_UNCAP + "\n" , FOO_UNCAP } ,
- { FOO_UNCAP + "\r", FOO_UNCAP },
- { FOO_UNCAP + " \r", FOO_UNCAP + " " },
- { "foo", "fo"},
- { "foo\nfoo", "foo\nfo" },
- { "\n", "" },
- { "\r", "" },
- { "\r\n", "" },
- { null, null },
- { "", "" },
- { "a", "" },
+ {FOO_UNCAP + "\r\n", FOO_UNCAP},
+ {FOO_UNCAP + "\n", FOO_UNCAP},
+ {FOO_UNCAP + "\r", FOO_UNCAP},
+ {FOO_UNCAP + " \r", FOO_UNCAP + " "},
+ {"foo", "fo"},
+ {"foo\nfoo", "foo\nfo"},
+ {"\n", ""},
+ {"\r", ""},
+ {"\r\n", ""},
+ {null, null},
+ {"", ""},
+ {"a", ""},
};
for (final String[] chopCase : chopCases) {
final String original = chopCase[0];
@@ -1427,22 +1428,22 @@
public void testChomp() {
final String[][] chompCases = {
- { FOO_UNCAP + "\r\n", FOO_UNCAP },
- { FOO_UNCAP + "\n" , FOO_UNCAP },
- { FOO_UNCAP + "\r", FOO_UNCAP },
- { FOO_UNCAP + " \r", FOO_UNCAP + " " },
- { FOO_UNCAP, FOO_UNCAP },
- { FOO_UNCAP + "\n\n", FOO_UNCAP + "\n"},
- { FOO_UNCAP + "\r\n\r\n", FOO_UNCAP + "\r\n" },
- { "foo\nfoo", "foo\nfoo" },
- { "foo\n\rfoo", "foo\n\rfoo" },
- { "\n", "" },
- { "\r", "" },
- { "a", "a" },
- { "\r\n", "" },
- { "", "" },
- { null, null },
- { FOO_UNCAP + "\n\r", FOO_UNCAP + "\n"}
+ {FOO_UNCAP + "\r\n", FOO_UNCAP},
+ {FOO_UNCAP + "\n", FOO_UNCAP},
+ {FOO_UNCAP + "\r", FOO_UNCAP},
+ {FOO_UNCAP + " \r", FOO_UNCAP + " "},
+ {FOO_UNCAP, FOO_UNCAP},
+ {FOO_UNCAP + "\n\n", FOO_UNCAP + "\n"},
+ {FOO_UNCAP + "\r\n\r\n", FOO_UNCAP + "\r\n"},
+ {"foo\nfoo", "foo\nfoo"},
+ {"foo\n\rfoo", "foo\n\rfoo"},
+ {"\n", ""},
+ {"\r", ""},
+ {"a", "a"},
+ {"\r\n", ""},
+ {"", ""},
+ {null, null},
+ {FOO_UNCAP + "\n\r", FOO_UNCAP + "\n"}
};
for (final String[] chompCase : chompCases) {
final String original = chompCase[0];
@@ -1501,7 +1502,7 @@
assertEquals("abcxx", StringUtils.rightPad("abc", 5, 'x'));
final String str = StringUtils.rightPad("aaa", 10000, 'a'); // bigger than pad length
assertEquals(10000, str.length());
- assertTrue(StringUtils.containsOnly(str, new char[] {'a'}));
+ assertTrue(StringUtils.containsOnly(str, new char[]{'a'}));
}
@Test
@@ -1517,7 +1518,7 @@
assertEquals("abc ", StringUtils.rightPad("abc", 5, null));
assertEquals("abc ", StringUtils.rightPad("abc", 5, ""));
}
-
+
//-----------------------------------------------------------------------
@Test
public void testLeftPad_StringInt() {
@@ -1526,7 +1527,7 @@
assertEquals(" abc", StringUtils.leftPad("abc", 5));
assertEquals("abc", StringUtils.leftPad("abc", 2));
}
-
+
@Test
public void testLeftPad_StringIntChar() {
assertNull(StringUtils.leftPad(null, 5, ' '));
@@ -1537,9 +1538,9 @@
assertEquals("abc", StringUtils.leftPad("abc", 2, ' '));
final String str = StringUtils.leftPad("aaa", 10000, 'a'); // bigger than pad length
assertEquals(10000, str.length());
- assertTrue(StringUtils.containsOnly(str, new char[] {'a'}));
+ assertTrue(StringUtils.containsOnly(str, new char[]{'a'}));
}
-
+
@Test
public void testLeftPad_StringIntString() {
assertNull(StringUtils.leftPad(null, 5, "-+"));
@@ -1581,7 +1582,7 @@
assertEquals(1, StringUtils.length(new StringBuilder(" ")));
assertEquals(8, StringUtils.length(new StringBuilder("ABCDEFGH")));
}
-
+
@Test
public void testLength_CharBuffer() {
assertEquals(0, StringUtils.length(CharBuffer.wrap("")));
@@ -1605,7 +1606,7 @@
assertEquals(" a ", StringUtils.center("a", 4));
assertEquals(" a ", StringUtils.center("a", 5));
}
-
+
@Test
public void testCenter_StringIntChar() {
assertNull(StringUtils.center(null, -1, ' '));
@@ -1621,7 +1622,7 @@
assertEquals(" a ", StringUtils.center("a", 5, ' '));
assertEquals("xxaxx", StringUtils.center("a", 5, 'x'));
}
-
+
@Test
public void testCenter_StringIntString() {
assertNull(StringUtils.center(null, 4, null));
@@ -1660,18 +1661,18 @@
//-----------------------------------------------------------------------
@Test
public void testReverse_String() {
- assertNull(StringUtils.reverse(null) );
- assertEquals("", StringUtils.reverse("") );
- assertEquals("sdrawkcab", StringUtils.reverse("backwards") );
+ assertNull(StringUtils.reverse(null));
+ assertEquals("", StringUtils.reverse(""));
+ assertEquals("sdrawkcab", StringUtils.reverse("backwards"));
}
-
+
@Test
public void testReverseDelimited_StringChar() {
- assertNull(StringUtils.reverseDelimited(null, '.') );
- assertEquals("", StringUtils.reverseDelimited("", '.') );
- assertEquals("c.b.a", StringUtils.reverseDelimited("a.b.c", '.') );
- assertEquals("a b c", StringUtils.reverseDelimited("a b c", '.') );
- assertEquals("", StringUtils.reverseDelimited("", '.') );
+ assertNull(StringUtils.reverseDelimited(null, '.'));
+ assertEquals("", StringUtils.reverseDelimited("", '.'));
+ assertEquals("c.b.a", StringUtils.reverseDelimited("a.b.c", '.'));
+ assertEquals("a b c", StringUtils.reverseDelimited("a b c", '.'));
+ assertEquals("", StringUtils.reverseDelimited("", '.'));
}
//-----------------------------------------------------------------------
@@ -1792,40 +1793,40 @@
assertEquals("abcdefg", StringUtils.abbreviate("abcdefg", 8));
assertEquals("a...", StringUtils.abbreviate("abcdefg", 4));
assertEquals("", StringUtils.abbreviate("", 4));
-
+
try {
@SuppressWarnings("unused")
final
String res = StringUtils.abbreviate("abc", 3);
fail("StringUtils.abbreviate expecting IllegalArgumentException");
} catch (final IllegalArgumentException ex) {
- // empty
- }
+ // empty
+ }
}
-
+
@Test
public void testAbbreviate_StringIntInt() {
assertNull(StringUtils.abbreviate(null, 10, 12));
assertEquals("", StringUtils.abbreviate("", 0, 10));
assertEquals("", StringUtils.abbreviate("", 2, 10));
-
+
try {
@SuppressWarnings("unused")
final
String res = StringUtils.abbreviate("abcdefghij", 0, 3);
fail("StringUtils.abbreviate expecting IllegalArgumentException");
} catch (final IllegalArgumentException ex) {
- // empty
- }
+ // empty
+ }
try {
@SuppressWarnings("unused")
final
String res = StringUtils.abbreviate("abcdefghij", 5, 6);
fail("StringUtils.abbreviate expecting IllegalArgumentException");
} catch (final IllegalArgumentException ex) {
- // empty
- }
-
+ // empty
+ }
+
final String raspberry = "raspberry peach";
assertEquals("raspberry peach", StringUtils.abbreviate(raspberry, 11, 15));
@@ -1859,7 +1860,7 @@
final String actual = StringUtils.abbreviate(abcdefghijklmno, offset, maxWidth);
if (offset >= 0 && offset < abcdefghijklmno.length()) {
assertTrue(message + " -- should contain offset character",
- actual.indexOf((char)('a'+offset)) != -1);
+ actual.indexOf((char) ('a' + offset)) != -1);
}
assertTrue(message + " -- should not be greater than maxWidth",
actual.length() <= maxWidth);
@@ -1869,24 +1870,24 @@
@Test
public void testAbbreviateMiddle() {
// javadoc examples
- assertNull( StringUtils.abbreviateMiddle(null, null, 0) );
- assertEquals( "abc", StringUtils.abbreviateMiddle("abc", null, 0) );
- assertEquals( "abc", StringUtils.abbreviateMiddle("abc", ".", 0) );
- assertEquals( "abc", StringUtils.abbreviateMiddle("abc", ".", 3) );
- assertEquals( "ab.f", StringUtils.abbreviateMiddle("abcdef", ".", 4) );
+ assertNull(StringUtils.abbreviateMiddle(null, null, 0));
+ assertEquals("abc", StringUtils.abbreviateMiddle("abc", null, 0));
+ assertEquals("abc", StringUtils.abbreviateMiddle("abc", ".", 0));
+ assertEquals("abc", StringUtils.abbreviateMiddle("abc", ".", 3));
+ assertEquals("ab.f", StringUtils.abbreviateMiddle("abcdef", ".", 4));
// JIRA issue (LANG-405) example (slightly different than actual expected result)
- assertEquals(
- "A very long text with un...f the text is complete.",
- StringUtils.abbreviateMiddle(
- "A very long text with unimportant stuff in the middle but interesting start and " +
- "end to see if the text is complete.", "...", 50) );
+ assertEquals(
+ "A very long text with un...f the text is complete.",
+ StringUtils.abbreviateMiddle(
+ "A very long text with unimportant stuff in the middle but interesting start and " +
+ "end to see if the text is complete.", "...", 50));
// Test a much longer text :)
final String longText = "Start text" + StringUtils.repeat("x", 10000) + "Close text";
- assertEquals(
- "Start text->Close text",
- StringUtils.abbreviateMiddle( longText, "->", 22 ) );
+ assertEquals(
+ "Start text->Close text",
+ StringUtils.abbreviateMiddle(longText, "->", 22));
// Test negative length
assertEquals("abc", StringUtils.abbreviateMiddle("abc", ".", -1));
@@ -1938,16 +1939,16 @@
//-----------------------------------------------------------------------
@Test
public void testGetLevenshteinDistance_StringString() {
- assertEquals(0, StringUtils.getLevenshteinDistance("", "") );
- assertEquals(1, StringUtils.getLevenshteinDistance("", "a") );
- assertEquals(7, StringUtils.getLevenshteinDistance("aaapppp", "") );
- assertEquals(1, StringUtils.getLevenshteinDistance("frog", "fog") );
- assertEquals(3, StringUtils.getLevenshteinDistance("fly", "ant") );
- assertEquals(7, StringUtils.getLevenshteinDistance("elephant", "hippo") );
- assertEquals(7, StringUtils.getLevenshteinDistance("hippo", "elephant") );
- assertEquals(8, StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz") );
- assertEquals(8, StringUtils.getLevenshteinDistance("zzzzzzzz", "hippo") );
- assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo") );
+ assertEquals(0, StringUtils.getLevenshteinDistance("", ""));
+ assertEquals(1, StringUtils.getLevenshteinDistance("", "a"));
+ assertEquals(7, StringUtils.getLevenshteinDistance("aaapppp", ""));
+ assertEquals(1, StringUtils.getLevenshteinDistance("frog", "fog"));
+ assertEquals(3, StringUtils.getLevenshteinDistance("fly", "ant"));
+ assertEquals(7, StringUtils.getLevenshteinDistance("elephant", "hippo"));
+ assertEquals(7, StringUtils.getLevenshteinDistance("hippo", "elephant"));
+ assertEquals(8, StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz"));
+ assertEquals(8, StringUtils.getLevenshteinDistance("zzzzzzzz", "hippo"));
+ assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo"));
}
@Test(expected = IllegalArgumentException.class)
@@ -1971,7 +1972,7 @@
// unequal strings, zero threshold
assertEquals(-1, StringUtils.getLevenshteinDistance("b", "a", 0));
assertEquals(-1, StringUtils.getLevenshteinDistance("a", "b", 0));
-
+
// equal strings
assertEquals(0, StringUtils.getLevenshteinDistance("aa", "aa", 0));
assertEquals(0, StringUtils.getLevenshteinDistance("aa", "aa", 2));
@@ -1979,14 +1980,14 @@
// same length
assertEquals(-1, StringUtils.getLevenshteinDistance("aaa", "bbb", 2));
assertEquals(3, StringUtils.getLevenshteinDistance("aaa", "bbb", 3));
-
+
// big stripe
assertEquals(6, StringUtils.getLevenshteinDistance("aaaaaa", "b", 10));
// distance less than threshold
assertEquals(7, StringUtils.getLevenshteinDistance("aaapppp", "b", 8));
assertEquals(3, StringUtils.getLevenshteinDistance("a", "bbb", 4));
-
+
// distance equal to threshold
assertEquals(7, StringUtils.getLevenshteinDistance("aaapppp", "b", 7));
assertEquals(3, StringUtils.getLevenshteinDistance("a", "bbb", 3));
@@ -2005,38 +2006,38 @@
assertEquals(-1, StringUtils.getLevenshteinDistance("1234567", "12345", 1));
// old getLevenshteinDistance test cases
- assertEquals(1, StringUtils.getLevenshteinDistance("frog", "fog",1) );
- assertEquals(3, StringUtils.getLevenshteinDistance("fly", "ant",3) );
- assertEquals(7, StringUtils.getLevenshteinDistance("elephant", "hippo",7) );
- assertEquals(-1, StringUtils.getLevenshteinDistance("elephant", "hippo",6) );
- assertEquals(7, StringUtils.getLevenshteinDistance("hippo", "elephant",7) );
- assertEquals(-1, StringUtils.getLevenshteinDistance("hippo", "elephant",6) );
- assertEquals(8, StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz",8) );
- assertEquals(8, StringUtils.getLevenshteinDistance("zzzzzzzz", "hippo",8) );
- assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo",1) );
+ assertEquals(1, StringUtils.getLevenshteinDistance("frog", "fog", 1));
+ assertEquals(3, StringUtils.getLevenshteinDistance("fly", "ant", 3));
+ assertEquals(7, StringUtils.getLevenshteinDistance("elephant", "hippo", 7));
+ assertEquals(-1, StringUtils.getLevenshteinDistance("elephant", "hippo", 6));
+ assertEquals(7, StringUtils.getLevenshteinDistance("hippo", "elephant", 7));
+ assertEquals(-1, StringUtils.getLevenshteinDistance("hippo", "elephant", 6));
+ assertEquals(8, StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz", 8));
+ assertEquals(8, StringUtils.getLevenshteinDistance("zzzzzzzz", "hippo", 8));
+ assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo", 1));
- assertEquals(1, StringUtils.getLevenshteinDistance("frog", "fog", Integer.MAX_VALUE) );
- assertEquals(3, StringUtils.getLevenshteinDistance("fly", "ant", Integer.MAX_VALUE) );
- assertEquals(7, StringUtils.getLevenshteinDistance("elephant", "hippo", Integer.MAX_VALUE) );
- assertEquals(7, StringUtils.getLevenshteinDistance("hippo", "elephant", Integer.MAX_VALUE) );
- assertEquals(8, StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz", Integer.MAX_VALUE) );
- assertEquals(8, StringUtils.getLevenshteinDistance("zzzzzzzz", "hippo", Integer.MAX_VALUE) );
+ assertEquals(1, StringUtils.getLevenshteinDistance("frog", "fog", Integer.MAX_VALUE));
+ assertEquals(3, StringUtils.getLevenshteinDistance("fly", "ant", Integer.MAX_VALUE));
+ assertEquals(7, StringUtils.getLevenshteinDistance("elephant", "hippo", Integer.MAX_VALUE));
+ assertEquals(7, StringUtils.getLevenshteinDistance("hippo", "elephant", Integer.MAX_VALUE));
+ assertEquals(8, StringUtils.getLevenshteinDistance("hippo", "zzzzzzzz", Integer.MAX_VALUE));
+ assertEquals(8, StringUtils.getLevenshteinDistance("zzzzzzzz", "hippo", Integer.MAX_VALUE));
assertEquals(1, StringUtils.getLevenshteinDistance("hello", "hallo", Integer.MAX_VALUE));
}
@Test(expected = IllegalArgumentException.class)
public void testGetLevenshteinDistance_NullStringInt() throws Exception {
- StringUtils.getLevenshteinDistance(null, "a", 0);
+ StringUtils.getLevenshteinDistance(null, "a", 0);
}
@Test(expected = IllegalArgumentException.class)
public void testGetLevenshteinDistance_StringNullInt() throws Exception {
- StringUtils.getLevenshteinDistance("a", null, 0);
+ StringUtils.getLevenshteinDistance("a", null, 0);
}
@Test(expected = IllegalArgumentException.class)
public void testGetLevenshteinDistance_StringStringNegativeInt() throws Exception {
- StringUtils.getLevenshteinDistance("a", "a", -1);
+ StringUtils.getLevenshteinDistance("a", "a", -1);
}
@Test
@@ -2052,17 +2053,17 @@
@Test(expected = IllegalArgumentException.class)
public void testGetJaroWinklerDistance_NullNull() throws Exception {
- StringUtils.getJaroWinklerDistance(null, null);
+ StringUtils.getJaroWinklerDistance(null, null);
}
@Test(expected = IllegalArgumentException.class)
public void testGetJaroWinklerDistance_StringNull() throws Exception {
- StringUtils.getJaroWinklerDistance(" ", null);
+ StringUtils.getJaroWinklerDistance(" ", null);
}
@Test(expected = IllegalArgumentException.class)
public void testGetJaroWinklerDistance_NullString() throws Exception {
- StringUtils.getJaroWinklerDistance(null, "clear");
+ StringUtils.getJaroWinklerDistance(null, "clear");
}
@Test
@@ -2146,37 +2147,37 @@
assertNull(StringUtils.removeStart(null, null));
assertNull(StringUtils.removeStart(null, ""));
assertNull(StringUtils.removeStart(null, "a"));
-
+
// StringUtils.removeStart(*, null) = *
assertEquals(StringUtils.removeStart("", null), "");
assertEquals(StringUtils.removeStart("", ""), "");
assertEquals(StringUtils.removeStart("", "a"), "");
-
+
// All others:
assertEquals(StringUtils.removeStart("www.domain.com", "www."), "domain.com");
assertEquals(StringUtils.removeStart("domain.com", "www."), "domain.com");
- assertEquals(StringUtils.removeStart("domain.com", ""), "domain.com");
- assertEquals(StringUtils.removeStart("domain.com", null), "domain.com");
+ assertEquals(StringUtils.removeStart("domain.com", ""), "domain.com");
+ assertEquals(StringUtils.removeStart("domain.com", null), "domain.com");
}
-
+
@Test
public void testRemoveStartIgnoreCase() {
// StringUtils.removeStart("", *) = ""
assertNull("removeStartIgnoreCase(null, null)", StringUtils.removeStartIgnoreCase(null, null));
assertNull("removeStartIgnoreCase(null, \"\")", StringUtils.removeStartIgnoreCase(null, ""));
assertNull("removeStartIgnoreCase(null, \"a\")", StringUtils.removeStartIgnoreCase(null, "a"));
-
+
// StringUtils.removeStart(*, null) = *
assertEquals("removeStartIgnoreCase(\"\", null)", StringUtils.removeStartIgnoreCase("", null), "");
assertEquals("removeStartIgnoreCase(\"\", \"\")", StringUtils.removeStartIgnoreCase("", ""), "");
assertEquals("removeStartIgnoreCase(\"\", \"a\")", StringUtils.removeStartIgnoreCase("", "a"), "");
-
+
// All others:
assertEquals("removeStartIgnoreCase(\"www.domain.com\", \"www.\")", StringUtils.removeStartIgnoreCase("www.domain.com", "www."), "domain.com");
assertEquals("removeStartIgnoreCase(\"domain.com\", \"www.\")", StringUtils.removeStartIgnoreCase("domain.com", "www."), "domain.com");
- assertEquals("removeStartIgnoreCase(\"domain.com\", \"\")", StringUtils.removeStartIgnoreCase("domain.com", ""), "domain.com");
- assertEquals("removeStartIgnoreCase(\"domain.com\", null)", StringUtils.removeStartIgnoreCase("domain.com", null), "domain.com");
-
+ assertEquals("removeStartIgnoreCase(\"domain.com\", \"\")", StringUtils.removeStartIgnoreCase("domain.com", ""), "domain.com");
+ assertEquals("removeStartIgnoreCase(\"domain.com\", null)", StringUtils.removeStartIgnoreCase("domain.com", null), "domain.com");
+
// Case insensitive:
assertEquals("removeStartIgnoreCase(\"www.domain.com\", \"WWW.\")", StringUtils.removeStartIgnoreCase("www.domain.com", "WWW."), "domain.com");
}
@@ -2187,18 +2188,18 @@
assertNull(StringUtils.removeEnd(null, null));
assertNull(StringUtils.removeEnd(null, ""));
assertNull(StringUtils.removeEnd(null, "a"));
-
+
// StringUtils.removeEnd(*, null) = *
assertEquals(StringUtils.removeEnd("", null), "");
assertEquals(StringUtils.removeEnd("", ""), "");
assertEquals(StringUtils.removeEnd("", "a"), "");
-
+
// All others:
assertEquals(StringUtils.removeEnd("www.domain.com.", ".com"), "www.domain.com.");
assertEquals(StringUtils.removeEnd("www.domain.com", ".com"), "www.domain");
assertEquals(StringUtils.removeEnd("www.domain", ".com"), "www.domain");
- assertEquals(StringUtils.removeEnd("domain.com", ""), "domain.com");
- assertEquals(StringUtils.removeEnd("domain.com", null), "domain.com");
+ assertEquals(StringUtils.removeEnd("domain.com", ""), "domain.com");
+ assertEquals(StringUtils.removeEnd("domain.com", null), "domain.com");
}
@Test
@@ -2207,18 +2208,18 @@
assertNull("removeEndIgnoreCase(null, null)", StringUtils.removeEndIgnoreCase(null, null));
assertNull("removeEndIgnoreCase(null, \"\")", StringUtils.removeEndIgnoreCase(null, ""));
assertNull("removeEndIgnoreCase(null, \"a\")", StringUtils.removeEndIgnoreCase(null, "a"));
-
+
// StringUtils.removeEnd(*, null) = *
assertEquals("removeEndIgnoreCase(\"\", null)", StringUtils.removeEndIgnoreCase("", null), "");
assertEquals("removeEndIgnoreCase(\"\", \"\")", StringUtils.removeEndIgnoreCase("", ""), "");
assertEquals("removeEndIgnoreCase(\"\", \"a\")", StringUtils.removeEndIgnoreCase("", "a"), "");
-
+
// All others:
assertEquals("removeEndIgnoreCase(\"www.domain.com.\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain.com.", ".com"), "www.domain.com.");
assertEquals("removeEndIgnoreCase(\"www.domain.com\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain.com", ".com"), "www.domain");
assertEquals("removeEndIgnoreCase(\"www.domain\", \".com\")", StringUtils.removeEndIgnoreCase("www.domain", ".com"), "www.domain");
- assertEquals("removeEndIgnoreCase(\"domain.com\", \"\")", StringUtils.removeEndIgnoreCase("domain.com", ""), "domain.com");
- assertEquals("removeEndIgnoreCase(\"domain.com\", null)", StringUtils.removeEndIgnoreCase("domain.com", null), "domain.com");
+ assertEquals("removeEndIgnoreCase(\"domain.com\", \"\")", StringUtils.removeEndIgnoreCase("domain.com", ""), "domain.com");
+ assertEquals("removeEndIgnoreCase(\"domain.com\", null)", StringUtils.removeEndIgnoreCase("domain.com", null), "domain.com");
// Case insensitive:
assertEquals("removeEndIgnoreCase(\"www.domain.com\", \".COM\")", StringUtils.removeEndIgnoreCase("www.domain.com", ".COM"), "www.domain");
@@ -2231,25 +2232,25 @@
assertNull(StringUtils.remove(null, null));
assertNull(StringUtils.remove(null, ""));
assertNull(StringUtils.remove(null, "a"));
-
+
// StringUtils.remove("", *) = ""
assertEquals("", StringUtils.remove("", null));
assertEquals("", StringUtils.remove("", ""));
assertEquals("", StringUtils.remove("", "a"));
-
+
// StringUtils.remove(*, null) = *
assertNull(StringUtils.remove(null, null));
assertEquals("", StringUtils.remove("", null));
assertEquals("a", StringUtils.remove("a", null));
-
+
// StringUtils.remove(*, "") = *
assertNull(StringUtils.remove(null, ""));
assertEquals("", StringUtils.remove("", ""));
assertEquals("a", StringUtils.remove("a", ""));
-
+
// StringUtils.remove("queued", "ue") = "qd"
assertEquals("qd", StringUtils.remove("queued", "ue"));
-
+
// StringUtils.remove("queued", "zz") = "queued"
assertEquals("queued", StringUtils.remove("queued", "zz"));
}
@@ -2260,43 +2261,43 @@
assertNull(StringUtils.remove(null, 'a'));
assertNull(StringUtils.remove(null, 'a'));
assertNull(StringUtils.remove(null, 'a'));
-
+
// StringUtils.remove("", *) = ""
assertEquals("", StringUtils.remove("", 'a'));
assertEquals("", StringUtils.remove("", 'a'));
assertEquals("", StringUtils.remove("", 'a'));
-
+
// StringUtils.remove("queued", 'u') = "qeed"
assertEquals("qeed", StringUtils.remove("queued", 'u'));
-
+
// StringUtils.remove("queued", 'z') = "queued"
assertEquals("queued", StringUtils.remove("queued", 'z'));
}
-
+
@Test
- public void testDifferenceAt_StringArray() {
- assertEquals(-1, StringUtils.indexOfDifference((String[])null));
- assertEquals(-1, StringUtils.indexOfDifference(new String[] {}));
- assertEquals(-1, StringUtils.indexOfDifference(new String[] {"abc"}));
- assertEquals(-1, StringUtils.indexOfDifference(new String[] {null, null}));
- assertEquals(-1, StringUtils.indexOfDifference(new String[] {"", ""}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {"", null}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {"abc", null, null}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {null, null, "abc"}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {"", "abc"}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {"abc", ""}));
- assertEquals(-1, StringUtils.indexOfDifference(new String[] {"abc", "abc"}));
- assertEquals(1, StringUtils.indexOfDifference(new String[] {"abc", "a"}));
- assertEquals(2, StringUtils.indexOfDifference(new String[] {"ab", "abxyz"}));
- assertEquals(2, StringUtils.indexOfDifference(new String[] {"abcde", "abxyz"}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {"abcde", "xyz"}));
- assertEquals(0, StringUtils.indexOfDifference(new String[] {"xyz", "abcde"}));
- assertEquals(7, StringUtils.indexOfDifference(new String[] {"i am a machine", "i am a robot"}));
+ public void testDifferenceAt_StringArray() {
+ assertEquals(-1, StringUtils.indexOfDifference((String[]) null));
+ assertEquals(-1, StringUtils.indexOfDifference(new String[]{}));
+ assertEquals(-1, StringUtils.indexOfDifference(new String[]{"abc"}));
+ assertEquals(-1, StringUtils.indexOfDifference(new String[]{null, null}));
+ assertEquals(-1, StringUtils.indexOfDifference(new String[]{"", ""}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{"", null}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{"abc", null, null}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{null, null, "abc"}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{"", "abc"}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{"abc", ""}));
+ assertEquals(-1, StringUtils.indexOfDifference(new String[]{"abc", "abc"}));
+ assertEquals(1, StringUtils.indexOfDifference(new String[]{"abc", "a"}));
+ assertEquals(2, StringUtils.indexOfDifference(new String[]{"ab", "abxyz"}));
+ assertEquals(2, StringUtils.indexOfDifference(new String[]{"abcde", "abxyz"}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{"abcde", "xyz"}));
+ assertEquals(0, StringUtils.indexOfDifference(new String[]{"xyz", "abcde"}));
+ assertEquals(7, StringUtils.indexOfDifference(new String[]{"i am a machine", "i am a robot"}));
}
-
+
@Test
public void testGetCommonPrefix_StringArray() {
- assertEquals("", StringUtils.getCommonPrefix((String[])null));
+ assertEquals("", StringUtils.getCommonPrefix((String[]) null));
assertEquals("", StringUtils.getCommonPrefix());
assertEquals("abc", StringUtils.getCommonPrefix("abc"));
assertEquals("", StringUtils.getCommonPrefix(null, null));
@@ -2339,8 +2340,8 @@
@Test
public void testLANG666() {
- assertEquals("12",StringUtils.stripEnd("120.00", ".0"));
- assertEquals("121",StringUtils.stripEnd("121.00", ".0"));
+ assertEquals("12", StringUtils.stripEnd("120.00", ".0"));
+ assertEquals("121", StringUtils.stripEnd("121.00", ".0"));
}
// Methods on StringUtils that are immutable in spirit (i.e. calculate the length)
@@ -2357,14 +2358,14 @@
// It may be String or it may be something else (String[], Object, Object[]) so
// don't actively test for that.
final Class<?>[] params = m.getParameterTypes();
- if ( params.length > 0 && (params[0] == CharSequence.class || params[0] == CharSequence[].class)) {
+ if (params.length > 0 && (params[0] == CharSequence.class || params[0] == CharSequence[].class)) {
fail("The method " + m + " appears to be mutable in spirit and therefore must not accept a CharSequence");
}
} else {
// Assume this is immutable in spirit and ensure the first parameter is not String.
// As above, it may be something other than CharSequence.
final Class<?>[] params = m.getParameterTypes();
- if ( params.length > 0 && (params[0] == String.class || params[0] == String[].class)) {
+ if (params.length > 0 && (params[0] == String.class || params[0] == String[].class)) {
fail("The method " + m + " appears to be immutable in spirit and therefore must not accept a String");
}
}
@@ -2390,7 +2391,7 @@
expectedBytes = expectedString.getBytes(Charset.forName(encoding));
assertEquals(expectedString, StringUtils.toString(expectedBytes, encoding));
}
-
+
@Test
public void testEscapeSurrogatePairs() throws Exception {
assertEquals("\uD83D\uDE30", StringEscapeUtils.escapeCsv("\uD83D\uDE30"));
@@ -2402,7 +2403,7 @@
assertEquals("\uDBFF\uDFFD", StringEscapeUtils.escapeHtml4("\uDBFF\uDFFD"));
assertEquals("\uDBFF\uDFFD", StringEscapeUtils.escapeXml("\uDBFF\uDFFD"));
}
-
+
/**
* Tests LANG-858.
*/
@@ -2411,7 +2412,7 @@
assertEquals("\\uDBFF\\uDFFD", StringEscapeUtils.escapeJava("\uDBFF\uDFFD")); //fail LANG-858
assertEquals("\\uDBFF\\uDFFD", StringEscapeUtils.escapeEcmaScript("\uDBFF\uDFFD")); //fail LANG-858
}
-
+
@Test
public void testUnescapeSurrogatePairs() throws Exception {
assertEquals("\uD83D\uDE30", StringEscapeUtils.unescapeCsv("\uD83D\uDE30"));
@@ -2428,23 +2429,23 @@
*/
@Test
public void testAppendIfMissing() {
- assertEquals("appendIfMissing(null,null)", null, StringUtils.appendIfMissing(null,null));
- assertEquals("appendIfMissing(abc,null)", "abc", StringUtils.appendIfMissing("abc",null));
- assertEquals("appendIfMissing(\"\",xyz)", "xyz", StringUtils.appendIfMissing("","xyz"));
- assertEquals("appendIfMissing(abc,xyz)", "abcxyz", StringUtils.appendIfMissing("abc","xyz"));
- assertEquals("appendIfMissing(abcxyz,xyz)", "abcxyz", StringUtils.appendIfMissing("abcxyz","xyz"));
- assertEquals("appendIfMissing(aXYZ,xyz)", "aXYZxyz", StringUtils.appendIfMissing("aXYZ","xyz"));
+ assertEquals("appendIfMissing(null,null)", null, StringUtils.appendIfMissing(null, null));
+ assertEquals("appendIfMissing(abc,null)", "abc", StringUtils.appendIfMissing("abc", null));
+ assertEquals("appendIfMissing(\"\",xyz)", "xyz", StringUtils.appendIfMissing("", "xyz"));
+ assertEquals("appendIfMissing(abc,xyz)", "abcxyz", StringUtils.appendIfMissing("abc", "xyz"));
+ assertEquals("appendIfMissing(abcxyz,xyz)", "abcxyz", StringUtils.appendIfMissing("abcxyz", "xyz"));
+ assertEquals("appendIfMissing(aXYZ,xyz)", "aXYZxyz", StringUtils.appendIfMissing("aXYZ", "xyz"));
- assertEquals("appendIfMissing(null,null,null)", null, StringUtils.appendIfMissing(null,null,(CharSequence[]) null));
- assertEquals("appendIfMissing(abc,null,null)", "abc", StringUtils.appendIfMissing("abc",null,(CharSequence[]) null));
- assertEquals("appendIfMissing(\"\",xyz,null))", "xyz", StringUtils.appendIfMissing("","xyz",(CharSequence[]) null));
- assertEquals("appendIfMissing(abc,xyz,{null})", "abcxyz", StringUtils.appendIfMissing("abc","xyz",new CharSequence[]{null}));
- assertEquals("appendIfMissing(abc,xyz,\"\")", "abc", StringUtils.appendIfMissing("abc","xyz",""));
- assertEquals("appendIfMissing(abc,xyz,mno)", "abcxyz", StringUtils.appendIfMissing("abc","xyz","mno"));
- assertEquals("appendIfMissing(abcxyz,xyz,mno)", "abcxyz", StringUtils.appendIfMissing("abcxyz","xyz","mno"));
- assertEquals("appendIfMissing(abcmno,xyz,mno)", "abcmno", StringUtils.appendIfMissing("abcmno","xyz","mno"));
- assertEquals("appendIfMissing(abcXYZ,xyz,mno)", "abcXYZxyz", StringUtils.appendIfMissing("abcXYZ","xyz","mno"));
- assertEquals("appendIfMissing(abcMNO,xyz,mno)", "abcMNOxyz", StringUtils.appendIfMissing("abcMNO","xyz","mno"));
+ assertEquals("appendIfMissing(null,null,null)", null, StringUtils.appendIfMissing(null, null, (CharSequence[]) null));
+ assertEquals("appendIfMissing(abc,null,null)", "abc", StringUtils.appendIfMissing("abc", null, (CharSequence[]) null));
+ assertEquals("appendIfMissing(\"\",xyz,null))", "xyz", StringUtils.appendIfMissing("", "xyz", (CharSequence[]) null));
+ assertEquals("appendIfMissing(abc,xyz,{null})", "abcxyz", StringUtils.appendIfMissing("abc", "xyz", new CharSequence[]{null}));
+ assertEquals("appendIfMissing(abc,xyz,\"\")", "abc", StringUtils.appendIfMissing("abc", "xyz", ""));
+ assertEquals("appendIfMissing(abc,xyz,mno)", "abcxyz", StringUtils.appendIfMissing("abc", "xyz", "mno"));
+ assertEquals("appendIfMissing(abcxyz,xyz,mno)", "abcxyz", StringUtils.appendIfMissing("abcxyz", "xyz", "mno"));
+ assertEquals("appendIfMissing(abcmno,xyz,mno)", "abcmno", StringUtils.appendIfMissing("abcmno", "xyz", "mno"));
+ assertEquals("appendIfMissing(abcXYZ,xyz,mno)", "abcXYZxyz", StringUtils.appendIfMissing("abcXYZ", "xyz", "mno"));
+ assertEquals("appendIfMissing(abcMNO,xyz,mno)", "abcMNOxyz", StringUtils.appendIfMissing("abcMNO", "xyz", "mno"));
}
/**
@@ -2452,23 +2453,23 @@
*/
@Test
public void testAppendIfMissingIgnoreCase() {
- assertEquals("appendIfMissingIgnoreCase(null,null)", null, StringUtils.appendIfMissingIgnoreCase(null,null));
- assertEquals("appendIfMissingIgnoreCase(abc,null)", "abc", StringUtils.appendIfMissingIgnoreCase("abc",null));
- assertEquals("appendIfMissingIgnoreCase(\"\",xyz)", "xyz", StringUtils.appendIfMissingIgnoreCase("","xyz"));
- assertEquals("appendIfMissingIgnoreCase(abc,xyz)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc","xyz"));
- assertEquals("appendIfMissingIgnoreCase(abcxyz,xyz)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz","xyz"));
- assertEquals("appendIfMissingIgnoreCase(abcXYZ,xyz)", "abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ","xyz"));
+ assertEquals("appendIfMissingIgnoreCase(null,null)", null, StringUtils.appendIfMissingIgnoreCase(null, null));
+ assertEquals("appendIfMissingIgnoreCase(abc,null)", "abc", StringUtils.appendIfMissingIgnoreCase("abc", null));
+ assertEquals("appendIfMissingIgnoreCase(\"\",xyz)", "xyz", StringUtils.appendIfMissingIgnoreCase("", "xyz"));
+ assertEquals("appendIfMissingIgnoreCase(abc,xyz)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz"));
+ assertEquals("appendIfMissingIgnoreCase(abcxyz,xyz)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz"));
+ assertEquals("appendIfMissingIgnoreCase(abcXYZ,xyz)", "abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz"));
- assertEquals("appendIfMissingIgnoreCase(null,null,null)", null, StringUtils.appendIfMissingIgnoreCase(null,null,(CharSequence[]) null));
- assertEquals("appendIfMissingIgnoreCase(abc,null,null)", "abc", StringUtils.appendIfMissingIgnoreCase("abc",null,(CharSequence[]) null));
- assertEquals("appendIfMissingIgnoreCase(\"\",xyz,null)", "xyz", StringUtils.appendIfMissingIgnoreCase("","xyz",(CharSequence[]) null));
- assertEquals("appendIfMissingIgnoreCase(abc,xyz,{null})", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc","xyz",new CharSequence[]{null}));
- assertEquals("appendIfMissingIgnoreCase(abc,xyz,\"\")", "abc", StringUtils.appendIfMissingIgnoreCase("abc","xyz",""));
- assertEquals("appendIfMissingIgnoreCase(abc,xyz,mno)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc","xyz","mno"));
- assertEquals("appendIfMissingIgnoreCase(abcxyz,xyz,mno)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz","xyz","mno"));
- assertEquals("appendIfMissingIgnoreCase(abcmno,xyz,mno)", "abcmno", StringUtils.appendIfMissingIgnoreCase("abcmno","xyz","mno"));
- assertEquals("appendIfMissingIgnoreCase(abcXYZ,xyz,mno)", "abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ","xyz","mno"));
- assertEquals("appendIfMissingIgnoreCase(abcMNO,xyz,mno)", "abcMNO", StringUtils.appendIfMissingIgnoreCase("abcMNO","xyz","mno"));
+ assertEquals("appendIfMissingIgnoreCase(null,null,null)", null, StringUtils.appendIfMissingIgnoreCase(null, null, (CharSequence[]) null));
+ assertEquals("appendIfMissingIgnoreCase(abc,null,null)", "abc", StringUtils.appendIfMissingIgnoreCase("abc", null, (CharSequence[]) null));
+ assertEquals("appendIfMissingIgnoreCase(\"\",xyz,null)", "xyz", StringUtils.appendIfMissingIgnoreCase("", "xyz", (CharSequence[]) null));
+ assertEquals("appendIfMissingIgnoreCase(abc,xyz,{null})", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}));
+ assertEquals("appendIfMissingIgnoreCase(abc,xyz,\"\")", "abc", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", ""));
+ assertEquals("appendIfMissingIgnoreCase(abc,xyz,mno)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abc", "xyz", "mno"));
+ assertEquals("appendIfMissingIgnoreCase(abcxyz,xyz,mno)", "abcxyz", StringUtils.appendIfMissingIgnoreCase("abcxyz", "xyz", "mno"));
+ assertEquals("appendIfMissingIgnoreCase(abcmno,xyz,mno)", "abcmno", StringUtils.appendIfMissingIgnoreCase("abcmno", "xyz", "mno"));
+ assertEquals("appendIfMissingIgnoreCase(abcXYZ,xyz,mno)", "abcXYZ", StringUtils.appendIfMissingIgnoreCase("abcXYZ", "xyz", "mno"));
+ assertEquals("appendIfMissingIgnoreCase(abcMNO,xyz,mno)", "abcMNO", StringUtils.appendIfMissingIgnoreCase("abcMNO", "xyz", "mno"));
}
/**
@@ -2476,23 +2477,23 @@
*/
@Test
public void testPrependIfMissing() {
- assertEquals("prependIfMissing(null,null)", null, StringUtils.prependIfMissing(null,null));
- assertEquals("prependIfMissing(abc,null)", "abc", StringUtils.prependIfMissing("abc",null));
- assertEquals("prependIfMissing(\"\",xyz)", "xyz", StringUtils.prependIfMissing("","xyz"));
- assertEquals("prependIfMissing(abc,xyz)", "xyzabc", StringUtils.prependIfMissing("abc","xyz"));
- assertEquals("prependIfMissing(xyzabc,xyz)", "xyzabc", StringUtils.prependIfMissing("xyzabc","xyz"));
- assertEquals("prependIfMissing(XYZabc,xyz)", "xyzXYZabc", StringUtils.prependIfMissing("XYZabc","xyz"));
+ assertEquals("prependIfMissing(null,null)", null, StringUtils.prependIfMissing(null, null));
+ assertEquals("prependIfMissing(abc,null)", "abc", StringUtils.prependIfMissing("abc", null));
+ assertEquals("prependIfMissing(\"\",xyz)", "xyz", StringUtils.prependIfMissing("", "xyz"));
+ assertEquals("prependIfMissing(abc,xyz)", "xyzabc", StringUtils.prependIfMissing("abc", "xyz"));
+ assertEquals("prependIfMissing(xyzabc,xyz)", "xyzabc", StringUtils.prependIfMissing("xyzabc", "xyz"));
+ assertEquals("prependIfMissing(XYZabc,xyz)", "xyzXYZabc", StringUtils.prependIfMissing("XYZabc", "xyz"));
- assertEquals("prependIfMissing(null,null null)", null, StringUtils.prependIfMissing(null,null,(CharSequence[]) null));
- assertEquals("prependIfMissing(abc,null,null)", "abc", StringUtils.prependIfMissing("abc",null,(CharSequence[]) null));
- assertEquals("prependIfMissing(\"\",xyz,null)", "xyz", StringUtils.prependIfMissing("","xyz",(CharSequence[]) null));
- assertEquals("prependIfMissing(abc,xyz,{null})","xyzabc", StringUtils.prependIfMissing("abc","xyz",new CharSequence[]{null}));
- assertEquals("prependIfMissing(abc,xyz,\"\")","abc", StringUtils.prependIfMissing("abc","xyz",""));
- assertEquals("prependIfMissing(abc,xyz,mno)","xyzabc", StringUtils.prependIfMissing("abc","xyz","mno"));
- assertEquals("prependIfMissing(xyzabc,xyz,mno)", "xyzabc", StringUtils.prependIfMissing("xyzabc","xyz","mno"));
- assertEquals("prependIfMissing(mnoabc,xyz,mno)", "mnoabc", StringUtils.prependIfMissing("mnoabc","xyz","mno"));
- assertEquals("prependIfMissing(XYZabc,xyz,mno)", "xyzXYZabc", StringUtils.prependIfMissing("XYZabc","xyz","mno"));
- assertEquals("prependIfMissing(MNOabc,xyz,mno)", "xyzMNOabc", StringUtils.prependIfMissing("MNOabc","xyz","mno"));
+ assertEquals("prependIfMissing(null,null null)", null, StringUtils.prependIfMissing(null, null, (CharSequence[]) null));
+ assertEquals("prependIfMissing(abc,null,null)", "abc", StringUtils.prependIfMissing("abc", null, (CharSequence[]) null));
+ assertEquals("prependIfMissing(\"\",xyz,null)", "xyz", StringUtils.prependIfMissing("", "xyz", (CharSequence[]) null));
+ assertEquals("prependIfMissing(abc,xyz,{null})", "xyzabc", StringUtils.prependIfMissing("abc", "xyz", new CharSequence[]{null}));
+ assertEquals("prependIfMissing(abc,xyz,\"\")", "abc", StringUtils.prependIfMissing("abc", "xyz", ""));
+ assertEquals("prependIfMissing(abc,xyz,mno)", "xyzabc", StringUtils.prependIfMissing("abc", "xyz", "mno"));
+ assertEquals("prependIfMissing(xyzabc,xyz,mno)", "xyzabc", StringUtils.prependIfMissing("xyzabc", "xyz", "mno"));
+ assertEquals("prependIfMissing(mnoabc,xyz,mno)", "mnoabc", StringUtils.prependIfMissing("mnoabc", "xyz", "mno"));
+ assertEquals("prependIfMissing(XYZabc,xyz,mno)", "xyzXYZabc", StringUtils.prependIfMissing("XYZabc", "xyz", "mno"));
+ assertEquals("prependIfMissing(MNOabc,xyz,mno)", "xyzMNOabc", StringUtils.prependIfMissing("MNOabc", "xyz", "mno"));
}
/**
@@ -2500,28 +2501,28 @@
*/
@Test
public void testPrependIfMissingIgnoreCase() {
- assertEquals("prependIfMissingIgnoreCase(null,null)", null, StringUtils.prependIfMissingIgnoreCase(null,null));
- assertEquals("prependIfMissingIgnoreCase(abc,null)", "abc", StringUtils.prependIfMissingIgnoreCase("abc",null));
- assertEquals("prependIfMissingIgnoreCase(\"\",xyz)", "xyz", StringUtils.prependIfMissingIgnoreCase("","xyz"));
- assertEquals("prependIfMissingIgnoreCase(abc,xyz)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc","xyz"));
- assertEquals("prependIfMissingIgnoreCase(xyzabc,xyz)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc","xyz"));
- assertEquals("prependIfMissingIgnoreCase(XYZabc,xyz)", "XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc","xyz"));
+ assertEquals("prependIfMissingIgnoreCase(null,null)", null, StringUtils.prependIfMissingIgnoreCase(null, null));
+ assertEquals("prependIfMissingIgnoreCase(abc,null)", "abc", StringUtils.prependIfMissingIgnoreCase("abc", null));
+ assertEquals("prependIfMissingIgnoreCase(\"\",xyz)", "xyz", StringUtils.prependIfMissingIgnoreCase("", "xyz"));
+ assertEquals("prependIfMissingIgnoreCase(abc,xyz)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz"));
+ assertEquals("prependIfMissingIgnoreCase(xyzabc,xyz)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz"));
+ assertEquals("prependIfMissingIgnoreCase(XYZabc,xyz)", "XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz"));
- assertEquals("prependIfMissingIgnoreCase(null,null null)", null, StringUtils.prependIfMissingIgnoreCase(null,null,(CharSequence[]) null));
- assertEquals("prependIfMissingIgnoreCase(abc,null,null)", "abc", StringUtils.prependIfMissingIgnoreCase("abc",null,(CharSequence[]) null));
- assertEquals("prependIfMissingIgnoreCase(\"\",xyz,null)", "xyz", StringUtils.prependIfMissingIgnoreCase("","xyz",(CharSequence[]) null));
- assertEquals("prependIfMissingIgnoreCase(abc,xyz,{null})","xyzabc", StringUtils.prependIfMissingIgnoreCase("abc","xyz",new CharSequence[]{null}));
- assertEquals("prependIfMissingIgnoreCase(abc,xyz,\"\")","abc", StringUtils.prependIfMissingIgnoreCase("abc","xyz",""));
- assertEquals("prependIfMissingIgnoreCase(abc,xyz,mno)","xyzabc", StringUtils.prependIfMissingIgnoreCase("abc","xyz","mno"));
- assertEquals("prependIfMissingIgnoreCase(xyzabc,xyz,mno)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc","xyz","mno"));
- assertEquals("prependIfMissingIgnoreCase(mnoabc,xyz,mno)", "mnoabc", StringUtils.prependIfMissingIgnoreCase("mnoabc","xyz","mno"));
- assertEquals("prependIfMissingIgnoreCase(XYZabc,xyz,mno)", "XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc","xyz","mno"));
- assertEquals("prependIfMissingIgnoreCase(MNOabc,xyz,mno)", "MNOabc", StringUtils.prependIfMissingIgnoreCase("MNOabc","xyz","mno"));
+ assertEquals("prependIfMissingIgnoreCase(null,null null)", null, StringUtils.prependIfMissingIgnoreCase(null, null, (CharSequence[]) null));
+ assertEquals("prependIfMissingIgnoreCase(abc,null,null)", "abc", StringUtils.prependIfMissingIgnoreCase("abc", null, (CharSequence[]) null));
+ assertEquals("prependIfMissingIgnoreCase(\"\",xyz,null)", "xyz", StringUtils.prependIfMissingIgnoreCase("", "xyz", (CharSequence[]) null));
+ assertEquals("prependIfMissingIgnoreCase(abc,xyz,{null})", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", new CharSequence[]{null}));
+ assertEquals("prependIfMissingIgnoreCase(abc,xyz,\"\")", "abc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", ""));
+ assertEquals("prependIfMissingIgnoreCase(abc,xyz,mno)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("abc", "xyz", "mno"));
+ assertEquals("prependIfMissingIgnoreCase(xyzabc,xyz,mno)", "xyzabc", StringUtils.prependIfMissingIgnoreCase("xyzabc", "xyz", "mno"));
+ assertEquals("prependIfMissingIgnoreCase(mnoabc,xyz,mno)", "mnoabc", StringUtils.prependIfMissingIgnoreCase("mnoabc", "xyz", "mno"));
+ assertEquals("prependIfMissingIgnoreCase(XYZabc,xyz,mno)", "XYZabc", StringUtils.prependIfMissingIgnoreCase("XYZabc", "xyz", "mno"));
+ assertEquals("prependIfMissingIgnoreCase(MNOabc,xyz,mno)", "MNOabc", StringUtils.prependIfMissingIgnoreCase("MNOabc", "xyz", "mno"));
}
-
+
/**
* Tests {@link StringUtils#toEncodedString(byte[], Charset)}
- *
+ *
* @see StringUtils#toEncodedString(byte[], Charset)
*/
@Test
@@ -2538,7 +2539,7 @@
expectedBytes = expectedString.getBytes(Charset.forName(encoding));
assertEquals(expectedString, StringUtils.toEncodedString(expectedBytes, Charset.forName(encoding)));
}
-
+
// -----------------------------------------------------------------------
@Test
