You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by br...@apache.org on 2015/05/19 21:39:19 UTC
[1/2] [lang] Format source code and remove spaces on empty lines
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>
[2/2] [lang] Format source code and remove spaces on empty lines
Posted by br...@apache.org.
Format source code and remove spaces on empty lines
Project: http://git-wip-us.apache.org/repos/asf/commons-lang/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-lang/commit/0343b4fd
Tree: http://git-wip-us.apache.org/repos/asf/commons-lang/tree/0343b4fd
Diff: http://git-wip-us.apache.org/repos/asf/commons-lang/diff/0343b4fd
Branch: refs/heads/master
Commit: 0343b4fda87161265acf30d5ee61e525e751358d
Parents: ff3492b
Author: Benedikt Ritter <br...@apache.org>
Authored: Tue May 19 21:38:52 2015 +0200
Committer: Benedikt Ritter <br...@apache.org>
Committed: Tue May 19 21:38:52 2015 +0200
----------------------------------------------------------------------
.../apache/commons/lang3/StringUtilsTest.java | 1327 +++++++++---------
1 file changed, 664 insertions(+), 663 deletions(-)
----------------------------------------------------------------------