Repository: commons-lang Updated Branches: refs/heads/master ff3492b06 -> 0343b4fda
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0343b4fd/src/test/java/org/apache/commons/lang3/StringUtilsTest.java ---------------------------------------------------------------------- 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 @@ import org.junit.Test; */ @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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 ")); - } - - @Test - 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")); - } - - @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")); - } - - @Test - 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 ")); - } - - @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 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 ")); + } + + @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")); + } + + @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")); + } + + @Test + 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 ")); + } + + @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")); + } + //----------------------------------------------------------------------- @Test public void testCaseFunctions() { @@ -219,57 +220,57 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { @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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { @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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { assertEquals("", res[0]); assertEquals("a", res[1]); assertEquals("", res[2]); - + str = ".a.."; res = StringUtils.splitPreserveAllTokens(str, '.'); assertEquals(4, res.length); @@ -815,7 +815,7 @@ public class StringUtilsTest { assertEquals("a", res[1]); assertEquals("", res[2]); assertEquals("", res[3]); - + str = "..a."; res = StringUtils.splitPreserveAllTokens(str, '.'); assertEquals(4, res.length); @@ -823,32 +823,32 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { // 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 @@ public class StringUtilsTest { } { - 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", 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", ":", 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, 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, 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]); - } + 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",":", 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", "", ":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", ":", 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", ":", 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", ":", 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]); - } + 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 class StringUtilsTest { 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("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("", 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"); //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 class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 class StringUtilsTest { 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 class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { assertEquals("abc ", StringUtils.rightPad("abc", 5, null)); assertEquals("abc ", StringUtils.rightPad("abc", 5, "")); } - + //----------------------------------------------------------------------- @Test public void testLeftPad_StringInt() { @@ -1526,7 +1527,7 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { //----------------------------------------------------------------------- @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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { 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 @@ public class StringUtilsTest { @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 @@ public class StringUtilsTest { //----------------------------------------------------------------------- @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 @@ public class StringUtilsTest { // 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 @@ public class StringUtilsTest { // 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 @@ public class StringUtilsTest { 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", 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", 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("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_Strin <TRUNCATED>
