| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.lang2; |
| |
| import java.lang.reflect.Constructor; |
| import java.lang.reflect.Modifier; |
| import java.util.Arrays; |
| import java.util.Iterator; |
| import java.util.Collection; |
| import java.util.Collections; |
| |
| import junit.framework.Test; |
| import junit.framework.TestCase; |
| import junit.framework.TestSuite; |
| import junit.textui.TestRunner; |
| |
| /** |
| * Unit tests {@link org.apache.commons.lang2.StringUtils}. |
| * |
| * @author Daniel L. Rall |
| * @author Stephen Colebourne |
| * @author <a href="mailto:ridesmet@users.sourceforge.net">Ringo De Smet</a> |
| * @author <a href="mailto:fredrik@westermarck.com>Fredrik Westermarck</a> |
| * @author Holger Krauth |
| * @author <a href="hps@intermeta.de">Henning P. Schmiedehausen</a> |
| * @author Phil Steitz |
| * @author Gary D. Gregory |
| * @author Al Chou |
| * @version $Id$ |
| */ |
| public class StringUtilsTest extends TestCase { |
| |
| static final String WHITESPACE; |
| static final String NON_WHITESPACE; |
| static final String TRIMMABLE; |
| static final String NON_TRIMMABLE; |
| static { |
| String ws = ""; |
| String nws = ""; |
| String tr = ""; |
| String ntr = ""; |
| for (int i = 0; i < Character.MAX_VALUE; i++) { |
| if (Character.isWhitespace((char) i)) { |
| ws += String.valueOf((char) i); |
| if (i > 32) { |
| ntr += String.valueOf((char) i); |
| } |
| } else if (i < 40) { |
| nws += String.valueOf((char) i); |
| } |
| } |
| for (int i = 0; i <= 32; i++) { |
| tr += String.valueOf((char) i); |
| } |
| WHITESPACE = ws; |
| NON_WHITESPACE = nws; |
| TRIMMABLE = tr; |
| NON_TRIMMABLE = ntr; |
| } |
| |
| 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 String[] MIXED_ARRAY_LIST = {null, "", "foo"}; |
| private static final Object[] MIXED_TYPE_LIST = {new String("foo"), new Long(2)}; |
| |
| private static final String SEPARATOR = ","; |
| 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"; |
| private static final String TEXT_LIST_NOSEP = "foobarbaz"; |
| |
| private static final String FOO_UNCAP = "foo"; |
| private static final String FOO_CAP = "Foo"; |
| |
| private static final String SENTENCE_UNCAP = "foo bar baz"; |
| private static final String SENTENCE_CAP = "Foo Bar Baz"; |
| |
| public StringUtilsTest(String name) { |
| super(name); |
| } |
| |
| public static void main(String[] args) { |
| TestRunner.run(suite()); |
| } |
| |
| public static Test suite() { |
| TestSuite suite = new TestSuite(StringUtilsTest.class); |
| suite.setName("StringUtilsTest Tests"); |
| return suite; |
| } |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| } |
| |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testConstructor() { |
| assertNotNull(new StringUtils()); |
| Constructor[] cons = StringUtils.class.getDeclaredConstructors(); |
| assertEquals(1, cons.length); |
| assertEquals(true, Modifier.isPublic(cons[0].getModifiers())); |
| assertEquals(true, Modifier.isPublic(StringUtils.class.getModifiers())); |
| assertEquals(false, Modifier.isFinal(StringUtils.class.getModifiers())); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testCaseFunctions() { |
| assertEquals(null, StringUtils.upperCase(null)); |
| assertEquals(null, StringUtils.lowerCase(null)); |
| assertEquals(null, StringUtils.capitalize(null)); |
| assertEquals(null, StringUtils.uncapitalise(null)); |
| assertEquals(null, StringUtils.uncapitalize(null)); |
| |
| assertEquals("capitalise(String) failed", |
| FOO_CAP, StringUtils.capitalise(FOO_UNCAP) ); |
| assertEquals("capitalise(empty-string) failed", |
| "", StringUtils.capitalise("") ); |
| assertEquals("capitalise(single-char-string) failed", |
| "X", StringUtils.capitalise("x") ); |
| assertEquals("capitalize(String) failed", |
| FOO_CAP, StringUtils.capitalize(FOO_UNCAP) ); |
| assertEquals("capitalize(empty-string) failed", |
| "", StringUtils.capitalize("") ); |
| assertEquals("capitalize(single-char-string) failed", |
| "X", StringUtils.capitalize("x") ); |
| assertEquals("uncapitalise(String) failed", |
| FOO_UNCAP, StringUtils.uncapitalise(FOO_CAP) ); |
| assertEquals("uncapitalise(empty-string) failed", |
| "", StringUtils.uncapitalise("") ); |
| assertEquals("uncapitalise(single-char-string) failed", |
| "x", StringUtils.uncapitalise("X") ); |
| assertEquals("uncapitalize(String) failed", |
| FOO_UNCAP, StringUtils.uncapitalize(FOO_CAP) ); |
| assertEquals("uncapitalize(empty-string) failed", |
| "", StringUtils.uncapitalize("") ); |
| assertEquals("uncapitalize(single-char-string) failed", |
| "x", StringUtils.uncapitalize("X") ); |
| |
| // reflection type of tests: Sentences. |
| assertEquals("uncapitalise(capitalise(String)) failed", |
| SENTENCE_UNCAP, StringUtils.uncapitalise(StringUtils.capitalise(SENTENCE_UNCAP)) ); |
| assertEquals("capitalise(uncapitalise(String)) failed", |
| SENTENCE_CAP, StringUtils.capitalise(StringUtils.uncapitalise(SENTENCE_CAP)) ); |
| assertEquals("uncapitalize(capitalize(String)) failed", |
| SENTENCE_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(SENTENCE_UNCAP)) ); |
| assertEquals("capitalize(uncapitalize(String)) failed", |
| SENTENCE_CAP, StringUtils.capitalize(StringUtils.uncapitalize(SENTENCE_CAP)) ); |
| |
| // reflection type of tests: One word. |
| assertEquals("uncapitalise(capitalise(String)) failed", |
| FOO_UNCAP, StringUtils.uncapitalise(StringUtils.capitalise(FOO_UNCAP)) ); |
| assertEquals("capitalise(uncapitalise(String)) failed", |
| FOO_CAP, StringUtils.capitalise(StringUtils.uncapitalise(FOO_CAP)) ); |
| assertEquals("uncapitalize(capitalize(String)) failed", |
| FOO_UNCAP, StringUtils.uncapitalize(StringUtils.capitalize(FOO_UNCAP)) ); |
| assertEquals("capitalize(uncapitalize(String)) failed", |
| FOO_CAP, StringUtils.capitalize(StringUtils.uncapitalize(FOO_CAP)) ); |
| |
| assertEquals("upperCase(String) failed", |
| "FOO TEST THING", StringUtils.upperCase("fOo test THING") ); |
| assertEquals("upperCase(empty-string) failed", |
| "", StringUtils.upperCase("") ); |
| assertEquals("lowerCase(String) failed", |
| "foo test thing", StringUtils.lowerCase("fOo test THING") ); |
| assertEquals("lowerCase(empty-string) failed", |
| "", StringUtils.lowerCase("") ); |
| |
| } |
| |
| public void testSwapCase_String() { |
| assertEquals(null, 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") ); |
| |
| String test = "This String contains a TitleCase character: \u01C8"; |
| String expect = "tHIS sTRING CONTAINS A tITLEcASE CHARACTER: \u01C9"; |
| assertEquals(expect, WordUtils.swapCase(test)); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testJoin_Objectarray() { |
| assertEquals(null, StringUtils.join(null)); |
| assertEquals("", StringUtils.join(EMPTY_ARRAY_LIST)); |
| assertEquals("", StringUtils.join(NULL_ARRAY_LIST)); |
| 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)); |
| } |
| |
| public void testJoin_ArrayChar() { |
| assertEquals(null, StringUtils.join((Object[]) null, ',')); |
| assertEquals(TEXT_LIST_CHAR, StringUtils.join(ARRAY_LIST, SEPARATOR_CHAR)); |
| assertEquals("", StringUtils.join(EMPTY_ARRAY_LIST, SEPARATOR_CHAR)); |
| 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("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)); |
| } |
| |
| public void testJoin_ArrayString() { |
| assertEquals(null, 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)); |
| |
| assertEquals(TEXT_LIST, StringUtils.join(ARRAY_LIST, SEPARATOR)); |
| 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("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)); |
| } |
| |
| public void testJoin_IteratorChar() { |
| assertEquals(null, StringUtils.join((Iterator) null, ',')); |
| assertEquals(TEXT_LIST_CHAR, StringUtils.join(Arrays.asList(ARRAY_LIST).iterator(), SEPARATOR_CHAR)); |
| assertEquals("", StringUtils.join(Arrays.asList(NULL_ARRAY_LIST).iterator(), SEPARATOR_CHAR)); |
| assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST).iterator(), SEPARATOR_CHAR)); |
| assertEquals("foo", StringUtils.join(Collections.singleton("foo").iterator(), 'x')); |
| } |
| |
| public void testJoin_IteratorString() { |
| assertEquals(null, StringUtils.join((Iterator) null, null)); |
| assertEquals(TEXT_LIST_NOSEP, StringUtils.join(Arrays.asList(ARRAY_LIST).iterator(), null)); |
| assertEquals(TEXT_LIST_NOSEP, StringUtils.join(Arrays.asList(ARRAY_LIST).iterator(), "")); |
| assertEquals("foo", StringUtils.join(Collections.singleton("foo").iterator(), "x")); |
| 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)); |
| } |
| |
| public void testJoin_CollectionChar() { |
| assertEquals(null, StringUtils.join((Collection) null, ',')); |
| assertEquals(TEXT_LIST_CHAR, StringUtils.join(Arrays.asList(ARRAY_LIST), SEPARATOR_CHAR)); |
| assertEquals("", StringUtils.join(Arrays.asList(NULL_ARRAY_LIST), SEPARATOR_CHAR)); |
| assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST), SEPARATOR_CHAR)); |
| assertEquals("foo", StringUtils.join(Collections.singleton("foo"), 'x')); |
| } |
| |
| public void testJoin_CollectionString() { |
| assertEquals(null, StringUtils.join((Collection) null, null)); |
| assertEquals(TEXT_LIST_NOSEP, StringUtils.join(Arrays.asList(ARRAY_LIST), null)); |
| assertEquals(TEXT_LIST_NOSEP, StringUtils.join(Arrays.asList(ARRAY_LIST), "")); |
| assertEquals("foo", StringUtils.join(Collections.singleton("foo"), "x")); |
| assertEquals("foo", StringUtils.join(Collections.singleton("foo"), null)); |
| |
| assertEquals("", StringUtils.join(Arrays.asList(NULL_ARRAY_LIST), null)); |
| |
| assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST), null)); |
| assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST), "")); |
| assertEquals("", StringUtils.join(Arrays.asList(EMPTY_ARRAY_LIST), SEPARATOR)); |
| |
| assertEquals(TEXT_LIST, StringUtils.join(Arrays.asList(ARRAY_LIST), SEPARATOR)); |
| } |
| |
| public void testConcatenate_Objectarray() { |
| assertEquals(null, StringUtils.concatenate(null)); |
| assertEquals("", StringUtils.concatenate(EMPTY_ARRAY_LIST)); |
| assertEquals("", StringUtils.concatenate(NULL_ARRAY_LIST)); |
| assertEquals("foo", StringUtils.concatenate(MIXED_ARRAY_LIST)); |
| assertEquals("foo2", StringUtils.concatenate(MIXED_TYPE_LIST)); |
| } |
| |
| public void testSplit_String() { |
| assertEquals(null, StringUtils.split(null)); |
| assertEquals(0, StringUtils.split("").length); |
| |
| 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]); |
| } |
| |
| public void testSplit_StringChar() { |
| assertEquals(null, 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 b c"; |
| res = StringUtils.split(str,' '); |
| assertEquals(3, res.length); |
| assertEquals("a", res[0]); |
| assertEquals("b", res[1]); |
| assertEquals("c", res[2]); |
| } |
| |
| public void testSplit_StringString_StringStringInt() { |
| assertEquals(null, StringUtils.split(null, ".")); |
| assertEquals(null, StringUtils.split(null, ".", 3)); |
| |
| assertEquals(0, StringUtils.split("", ".").length); |
| assertEquals(0, StringUtils.split("", ".", 3).length); |
| |
| innerTestSplit('.', ".", ' '); |
| innerTestSplit('.', ".", ','); |
| innerTestSplit('.', ".,", 'x'); |
| for (int i = 0; i < WHITESPACE.length(); i++) { |
| for (int j = 0; j < NON_WHITESPACE.length(); j++) { |
| innerTestSplit(WHITESPACE.charAt(i), null, NON_WHITESPACE.charAt(j)); |
| innerTestSplit(WHITESPACE.charAt(i), String.valueOf(WHITESPACE.charAt(i)), NON_WHITESPACE.charAt(j)); |
| } |
| } |
| |
| String[] results = null; |
| String[] expectedResults = {"ab", "de fg"}; |
| results = StringUtils.split("ab de fg", null, 2); |
| assertEquals(expectedResults.length, results.length); |
| for (int i = 0; i < expectedResults.length; i++) { |
| assertEquals(expectedResults[i], results[i]); |
| } |
| |
| String[] expectedResults2 = {"ab", "cd:ef"}; |
| 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(char separator, String sepStr, char noMatch) { |
| String msg = "Failed on separator hex(" + Integer.toHexString(separator) + |
| "), noMatch hex(" + Integer.toHexString(noMatch) + "), sepStr(" + sepStr + ")"; |
| |
| final String str = "a" + separator + "b" + separator + separator + noMatch + "c"; |
| String[] res; |
| // (str, sepStr) |
| res = StringUtils.split(str, sepStr); |
| assertEquals(msg, 3, res.length); |
| 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); |
| assertEquals(msg, "a", res[0]); |
| |
| res = StringUtils.split(str, sepStr, -1); |
| 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, 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]); |
| assertEquals(msg, str.substring(2), res[1]); |
| } |
| |
| public void testSplitByWholeString_StringStringBoolean() { |
| assertEquals( null, StringUtils.splitByWholeSeparator( null, "." ) ) ; |
| |
| assertEquals( 0, StringUtils.splitByWholeSeparator( "", "." ).length ) ; |
| |
| String stringToSplitOnNulls = "ab de fg" ; |
| String[] splitOnNullExpectedResults = { "ab", "de", "fg" } ; |
| |
| String[] splitOnNullResults = StringUtils.splitByWholeSeparator( "ab de fg", null ) ; |
| assertEquals( splitOnNullExpectedResults.length, splitOnNullResults.length ) ; |
| for ( int i = 0 ; i < splitOnNullExpectedResults.length ; i+= 1 ) { |
| assertEquals( splitOnNullExpectedResults[i], splitOnNullResults[i] ) ; |
| } |
| |
| String stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiously" ; |
| |
| String[] splitOnStringExpectedResults = { "abstemiously", "abstemiously" } ; |
| 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] ) ; |
| } |
| |
| String[] splitWithMultipleSeparatorExpectedResults = {"ab", "cd", "ef"}; |
| 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] ) ; |
| } |
| } |
| |
| public void testSplitByWholeString_StringStringBooleanInt() { |
| assertEquals( null, StringUtils.splitByWholeSeparator( null, ".", 3 ) ) ; |
| |
| assertEquals( 0, StringUtils.splitByWholeSeparator( "", ".", 3 ).length ) ; |
| |
| String stringToSplitOnNulls = "ab de fg" ; |
| String[] splitOnNullExpectedResults = { "ab", "de fg" } ; |
| //String[] splitOnNullExpectedResults = { "ab", "de" } ; |
| |
| 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] ) ; |
| } |
| |
| String stringToSplitOnCharactersAndString = "abstemiouslyaeiouyabstemiouslyaeiouyabstemiously" ; |
| |
| String[] splitOnStringExpectedResults = { "abstemiously", "abstemiouslyaeiouyabstemiously" } ; |
| //String[] splitOnStringExpectedResults = { "abstemiously", "abstemiously" } ; |
| 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] ) ; |
| } |
| } |
| |
| |
| public void testSplitPreserveAllTokens_String() { |
| assertEquals(null, 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); |
| assertEquals("", res[0]); |
| assertEquals("a", res[1]); |
| assertEquals("b", res[2]); |
| assertEquals(".c", res[3]); |
| |
| str = "a b .c"; |
| 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 "; |
| res = StringUtils.splitPreserveAllTokens(str); |
| assertEquals(4, res.length); |
| assertEquals("", res[0]); |
| assertEquals("a", res[1]); |
| assertEquals("", res[2]); |
| assertEquals("", res[3]); |
| |
| str = " a b"; |
| res = StringUtils.splitPreserveAllTokens(str); |
| assertEquals(4, res.length); |
| assertEquals("", res[0]); |
| assertEquals("a", res[1]); |
| assertEquals("", res[2]); |
| assertEquals("b", res[3]); |
| |
| str = "a" + WHITESPACE + "b" + NON_WHITESPACE + "c"; |
| 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]); |
| } |
| assertEquals("b" + NON_WHITESPACE + "c", res[WHITESPACE.length()]); |
| } |
| |
| public void testSplitPreserveAllTokens_StringChar() { |
| assertEquals(null, StringUtils.splitPreserveAllTokens(null, '.')); |
| assertEquals(0, StringUtils.splitPreserveAllTokens("", '.').length); |
| |
| String str = "a.b. c"; |
| String[] 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); |
| assertEquals("a", res[0]); |
| assertEquals("b", res[1]); |
| assertEquals("", res[2]); |
| assertEquals(" c", res[3]); |
| |
| str = ".a."; |
| res = StringUtils.splitPreserveAllTokens(str, '.'); |
| assertEquals(3, res.length); |
| assertEquals("", res[0]); |
| assertEquals("a", res[1]); |
| assertEquals("", res[2]); |
| |
| str = ".a.."; |
| res = StringUtils.splitPreserveAllTokens(str, '.'); |
| assertEquals(4, res.length); |
| assertEquals("", res[0]); |
| assertEquals("a", res[1]); |
| assertEquals("", res[2]); |
| assertEquals("", res[3]); |
| |
| str = "..a."; |
| res = StringUtils.splitPreserveAllTokens(str, '.'); |
| assertEquals(4, res.length); |
| assertEquals("", res[0]); |
| 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,' '); |
| 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(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,' '); |
| assertEquals(4, res.length); |
| assertEquals("", res[0]); |
| assertEquals("a", res[1]); |
| assertEquals("b", res[2]); |
| assertEquals("c", res[3]); |
| |
| str = " a b c"; |
| res = StringUtils.splitPreserveAllTokens(str,' '); |
| assertEquals(5, res.length); |
| assertEquals("", res[0]); |
| assertEquals("", res[1]); |
| assertEquals("a", res[2]); |
| assertEquals("b", res[3]); |
| assertEquals("c", res[4]); |
| |
| str = "a b c "; |
| res = StringUtils.splitPreserveAllTokens(str,' '); |
| assertEquals(4, res.length); |
| assertEquals("a", res[0]); |
| assertEquals("b", res[1]); |
| assertEquals("c", res[2]); |
| assertEquals("", res[3]); |
| |
| str = "a b c "; |
| res = StringUtils.splitPreserveAllTokens(str,' '); |
| assertEquals(5, res.length); |
| assertEquals("a", res[0]); |
| assertEquals("b", res[1]); |
| assertEquals("c", res[2]); |
| assertEquals("", res[3]); |
| assertEquals("", res[3]); |
| |
| // Match example in javadoc |
| { |
| String[] results = null; |
| 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]); |
| } |
| } |
| } |
| |
| public void testSplitPreserveAllTokens_StringString_StringStringInt() { |
| assertEquals(null, StringUtils.splitPreserveAllTokens(null, ".")); |
| assertEquals(null, StringUtils.splitPreserveAllTokens(null, ".", 3)); |
| |
| assertEquals(0, StringUtils.splitPreserveAllTokens("", ".").length); |
| assertEquals(0, StringUtils.splitPreserveAllTokens("", ".", 3).length); |
| |
| innerTestSplitPreserveAllTokens('.', ".", ' '); |
| innerTestSplitPreserveAllTokens('.', ".", ','); |
| innerTestSplitPreserveAllTokens('.', ".,", 'x'); |
| for (int i = 0; i < WHITESPACE.length(); i++) { |
| for (int j = 0; j < NON_WHITESPACE.length(); j++) { |
| innerTestSplitPreserveAllTokens(WHITESPACE.charAt(i), null, NON_WHITESPACE.charAt(j)); |
| innerTestSplitPreserveAllTokens(WHITESPACE.charAt(i), String.valueOf(WHITESPACE.charAt(i)), NON_WHITESPACE.charAt(j)); |
| } |
| } |
| |
| { |
| String[] results = null; |
| 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 = null; |
| String[] expectedResults = {"ab", " de fg"}; |
| results = StringUtils.splitPreserveAllTokens("ab de fg", null, 2); |
| System.out.println(""); |
| assertEquals(expectedResults.length, results.length); |
| for (int i = 0; i < expectedResults.length; i++) { |
| assertEquals(expectedResults[i], results[i]); |
| } |
| } |
| |
| { |
| String[] results = null; |
| 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 = null; |
| 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 = null; |
| 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[] expectedResults = {"ab", "cd:ef"}; |
| String[] results = null; |
| 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 = null; |
| 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 = null; |
| 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 = null; |
| 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 = null; |
| 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 = null; |
| 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(char separator, String sepStr, char noMatch) { |
| String msg = "Failed on separator hex(" + Integer.toHexString(separator) + |
| "), noMatch hex(" + Integer.toHexString(noMatch) + "), sepStr(" + sepStr + ")"; |
| |
| final String str = "a" + separator + "b" + separator + separator + noMatch + "c"; |
| String[] res; |
| // (str, sepStr) |
| res = StringUtils.splitPreserveAllTokens(str, sepStr); |
| 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]); |
| |
| final String str2 = separator + "a" + separator; |
| res = StringUtils.splitPreserveAllTokens(str2, sepStr); |
| assertEquals(msg, 3, res.length); |
| assertEquals(msg, "", res[0]); |
| assertEquals(msg, "a", res[1]); |
| assertEquals(msg, "", res[2]); |
| |
| res = StringUtils.splitPreserveAllTokens(str, sepStr, -1); |
| 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, 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]); |
| assertEquals(msg, str.substring(2), res[1]); |
| } |
| |
| public void testDeleteSpace_String() { |
| assertEquals(null, StringUtils.deleteSpaces(null)); |
| assertEquals("", StringUtils.deleteSpaces("")); |
| assertEquals("", StringUtils.deleteSpaces(" \t\t\n\n ")); |
| assertEquals("test", StringUtils.deleteSpaces("t \t\ne\rs\n\n \tt")); |
| } |
| |
| public void testDeleteWhitespace_String() { |
| assertEquals(null, StringUtils.deleteWhitespace(null)); |
| assertEquals("", StringUtils.deleteWhitespace("")); |
| assertEquals("", StringUtils.deleteWhitespace(" \u000C \t\t\u001F\n\n \u000B ")); |
| assertEquals("", StringUtils.deleteWhitespace(StringUtilsTest.WHITESPACE)); |
| assertEquals(StringUtilsTest.NON_WHITESPACE, StringUtils.deleteWhitespace(StringUtilsTest.NON_WHITESPACE)); |
| // Note: u-2007 and u-000A both cause problems in the source code |
| // it should ignore 2007 but delete 000A |
| assertEquals("\u00A0\u202F", StringUtils.deleteWhitespace(" \u00A0 \t\t\n\n \u202F ")); |
| assertEquals("\u00A0\u202F", StringUtils.deleteWhitespace("\u00A0\u202F")); |
| assertEquals("test", StringUtils.deleteWhitespace("\u000Bt \t\n\u0009e\rs\n\n \tt")); |
| } |
| |
| public void testReplace_StringStringString() { |
| assertEquals(null, StringUtils.replace(null, null, null)); |
| assertEquals(null, StringUtils.replace(null, null, "any")); |
| assertEquals(null, StringUtils.replace(null, "any", null)); |
| assertEquals(null, StringUtils.replace(null, "any", "any")); |
| |
| assertEquals("", StringUtils.replace("", null, null)); |
| assertEquals("", StringUtils.replace("", null, "any")); |
| assertEquals("", StringUtils.replace("", "any", null)); |
| assertEquals("", StringUtils.replace("", "any", "any")); |
| |
| assertEquals("FOO", StringUtils.replace("FOO", "", "any")); |
| assertEquals("FOO", StringUtils.replace("FOO", null, "any")); |
| assertEquals("FOO", StringUtils.replace("FOO", "F", null)); |
| assertEquals("FOO", StringUtils.replace("FOO", null, null)); |
| |
| assertEquals("", StringUtils.replace("foofoofoo", "foo", "")); |
| assertEquals("barbarbar", StringUtils.replace("foofoofoo", "foo", "bar")); |
| assertEquals("farfarfar", StringUtils.replace("foofoofoo", "oo", "ar")); |
| } |
| |
| public void testReplace_StringStringStringInt() { |
| assertEquals(null, StringUtils.replace(null, null, null, 2)); |
| assertEquals(null, StringUtils.replace(null, null, "any", 2)); |
| assertEquals(null, StringUtils.replace(null, "any", null, 2)); |
| assertEquals(null, StringUtils.replace(null, "any", "any", 2)); |
| |
| assertEquals("", StringUtils.replace("", null, null, 2)); |
| assertEquals("", StringUtils.replace("", null, "any", 2)); |
| assertEquals("", StringUtils.replace("", "any", null, 2)); |
| assertEquals("", StringUtils.replace("", "any", "any", 2)); |
| |
| 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)); |
| } |
| |
| public void testReplaceOnce_StringStringString() { |
| assertEquals(null, StringUtils.replaceOnce(null, null, null)); |
| assertEquals(null, StringUtils.replaceOnce(null, null, "any")); |
| assertEquals(null, StringUtils.replaceOnce(null, "any", null)); |
| assertEquals(null, StringUtils.replaceOnce(null, "any", "any")); |
| |
| assertEquals("", StringUtils.replaceOnce("", null, null)); |
| assertEquals("", StringUtils.replaceOnce("", null, "any")); |
| assertEquals("", StringUtils.replaceOnce("", "any", null)); |
| assertEquals("", StringUtils.replaceOnce("", "any", "any")); |
| |
| assertEquals("FOO", StringUtils.replaceOnce("FOO", "", "any")); |
| assertEquals("FOO", StringUtils.replaceOnce("FOO", null, "any")); |
| assertEquals("FOO", StringUtils.replaceOnce("FOO", "F", null)); |
| assertEquals("FOO", StringUtils.replaceOnce("FOO", null, null)); |
| |
| assertEquals("foofoo", StringUtils.replaceOnce("foofoofoo", "foo", "")); |
| } |
| |
| public void testReplaceChars_StringCharChar() { |
| assertEquals(null, StringUtils.replaceChars(null, 'b', 'z')); |
| assertEquals("", StringUtils.replaceChars("", 'b', 'z')); |
| assertEquals("azcza", StringUtils.replaceChars("abcba", 'b', 'z')); |
| assertEquals("abcba", StringUtils.replaceChars("abcba", 'x', 'z')); |
| } |
| |
| public void testReplaceChars_StringStringString() { |
| assertEquals(null, StringUtils.replaceChars(null, null, null)); |
| assertEquals(null, StringUtils.replaceChars(null, "", null)); |
| assertEquals(null, StringUtils.replaceChars(null, "a", null)); |
| assertEquals(null, StringUtils.replaceChars(null, null, "")); |
| assertEquals(null, StringUtils.replaceChars(null, null, "x")); |
| |
| assertEquals("", StringUtils.replaceChars("", null, null)); |
| assertEquals("", StringUtils.replaceChars("", "", null)); |
| assertEquals("", StringUtils.replaceChars("", "a", null)); |
| assertEquals("", StringUtils.replaceChars("", null, "")); |
| assertEquals("", StringUtils.replaceChars("", null, "x")); |
| |
| 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")); |
| } |
| |
| public void testOverlayString_StringStringIntInt() { |
| assertEquals("overlayString(String, String, int, int) failed", |
| "foo foor baz", StringUtils.overlayString(SENTENCE_UNCAP, FOO_UNCAP, 4, 6) ); |
| assertEquals("abef", StringUtils.overlayString("abcdef", "", 2, 4)); |
| assertEquals("abzzzzef", StringUtils.overlayString("abcdef", "zzzz", 2, 4)); |
| assertEquals("abcdzzzzcdef", StringUtils.overlayString("abcdef", "zzzz", 4, 2)); |
| try { |
| StringUtils.overlayString(null, "zzzz", 2, 4); |
| fail(); |
| } catch (NullPointerException ex) {} |
| try { |
| StringUtils.overlayString("abcdef", null, 2, 4); |
| fail(); |
| } catch (NullPointerException ex) {} |
| try { |
| StringUtils.overlayString("abcdef", "zzzz", -1, 4); |
| fail(); |
| } catch (IndexOutOfBoundsException ex) {} |
| try { |
| StringUtils.overlayString("abcdef", "zzzz", 2, 8); |
| fail(); |
| } catch (IndexOutOfBoundsException ex) {} |
| } |
| |
| public void testOverlay_StringStringIntInt() { |
| assertEquals(null, StringUtils.overlay(null, null, 2, 4)); |
| assertEquals(null, StringUtils.overlay(null, null, -2, -4)); |
| |
| 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)); |
| assertEquals("zzzzabcdef", StringUtils.overlay("abcdef", "zzzz", -1, -2)); |
| assertEquals("abcdzzzz", StringUtils.overlay("abcdef", "zzzz", 4, 10)); |
| assertEquals("abcdzzzz", StringUtils.overlay("abcdef", "zzzz", 10, 4)); |
| assertEquals("abcdefzzzz", StringUtils.overlay("abcdef", "zzzz", 8, 10)); |
| assertEquals("abcdefzzzz", StringUtils.overlay("abcdef", "zzzz", 10, 8)); |
| } |
| |
| public void testRepeat_StringInt() { |
| assertEquals(null, StringUtils.repeat(null, 2)); |
| assertEquals("", StringUtils.repeat("ab", 0)); |
| assertEquals("", StringUtils.repeat("", 3)); |
| assertEquals("aaa", StringUtils.repeat("a", 3)); |
| assertEquals("ababab", StringUtils.repeat("ab", 3)); |
| assertEquals("abcabcabc", StringUtils.repeat("abc", 3)); |
| String str = StringUtils.repeat("a", 10000); // bigger than pad limit |
| assertEquals(10000, str.length()); |
| assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'})); |
| } |
| |
| public void testDeprecatedChompFunctions() { |
| assertEquals("chompLast(String) failed", |
| FOO_UNCAP, StringUtils.chompLast(FOO_UNCAP + "\n") ); |
| |
| assertEquals("chompLast(\"\") failed", |
| "", StringUtils.chompLast("") ); |
| assertEquals("chompLast(\"test\", \"test\") failed", |
| "test", StringUtils.chompLast("test", "tst") ); |
| |
| assertEquals("getChomp(String, String) failed", |
| "\n" + FOO_UNCAP, StringUtils.getChomp(FOO_UNCAP + "\n" + FOO_UNCAP, "\n") ); |
| assertEquals("getChomp(String, String) failed", |
| FOO_CAP, StringUtils.getChomp(FOO_CAP+FOO_CAP, FOO_CAP)); |
| assertEquals("getChomp(String, String) failed", |
| "", StringUtils.getChomp(FOO_UNCAP, FOO_CAP)); |
| |
| assertEquals("prechomp(String, String) failed", |
| FOO_UNCAP, StringUtils.prechomp(FOO_UNCAP + "\n" + FOO_UNCAP, "\n") ); |
| assertEquals("prechomp(String, String) failed", |
| FOO_UNCAP, StringUtils.prechomp(FOO_UNCAP, FOO_CAP)); |
| |
| assertEquals("getPrechomp(String, String) failed", |
| FOO_UNCAP + "\n", StringUtils.getPrechomp(FOO_UNCAP + "\n" + FOO_UNCAP, "\n") ); |
| assertEquals("getPrechomp(String, String) failed", |
| "", StringUtils.getPrechomp(FOO_CAP, FOO_UNCAP)); |
| |
| assertEquals("chopNewline(String, String) failed", |
| FOO_UNCAP, StringUtils.chopNewline(FOO_UNCAP + "\r\n") ); |
| } |
| |
| public void testChop() { |
| |
| String[][] chopCases = { |
| { 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 (int i = 0; i < chopCases.length; i++) { |
| String original = chopCases[i][0]; |
| String expectedResult = chopCases[i][1]; |
| assertEquals("chop(String) failed", |
| expectedResult, StringUtils.chop(original)); |
| } |
| } |
| |
| public void testChomp() { |
| |
| 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"} |
| }; |
| for (int i = 0; i < chompCases.length; i++) { |
| String original = chompCases[i][0]; |
| String expectedResult = chompCases[i][1]; |
| assertEquals("chomp(String) failed", |
| expectedResult, StringUtils.chomp(original)); |
| } |
| |
| assertEquals("chomp(String, String) failed", |
| "foo", StringUtils.chomp("foobar", "bar")); |
| assertEquals("chomp(String, String) failed", |
| "foobar", StringUtils.chomp("foobar", "baz")); |
| assertEquals("chomp(String, String) failed", |
| "foo", StringUtils.chomp("foo", "foooo")); |
| assertEquals("chomp(String, String) failed", |
| "foobar", StringUtils.chomp("foobar", "")); |
| assertEquals("chomp(String, String) failed", |
| "foobar", StringUtils.chomp("foobar", null)); |
| assertEquals("chomp(String, String) failed", |
| "", StringUtils.chomp("", "foo")); |
| assertEquals("chomp(String, String) failed", |
| "", StringUtils.chomp("", null)); |
| assertEquals("chomp(String, String) failed", |
| "", StringUtils.chomp("", "")); |
| assertEquals("chomp(String, String) failed", |
| null, StringUtils.chomp(null, "foo")); |
| assertEquals("chomp(String, String) failed", |
| null, StringUtils.chomp(null, null)); |
| assertEquals("chomp(String, String) failed", |
| null, StringUtils.chomp(null, "")); |
| assertEquals("chomp(String, String) failed", |
| "", StringUtils.chomp("foo", "foo")); |
| assertEquals("chomp(String, String) failed", |
| " ", StringUtils.chomp(" foo", "foo")); |
| assertEquals("chomp(String, String) failed", |
| "foo ", StringUtils.chomp("foo ", "foo")); |
| } |
| |
| public void testChopNewLine() { |
| |
| String[][] newLineCases = { |
| { FOO_UNCAP + "\r\n", FOO_UNCAP } , |
| { FOO_UNCAP + "\n" , FOO_UNCAP } , |
| { FOO_UNCAP + "\r", FOO_UNCAP + "\r" }, |
| { FOO_UNCAP, FOO_UNCAP }, |
| { FOO_UNCAP + "\n" + FOO_UNCAP , FOO_UNCAP + "\n" + FOO_UNCAP }, |
| { FOO_UNCAP + "\n\n", FOO_UNCAP + "\n"}, |
| { "\n", "" }, |
| { "", "" }, |
| { "\r\n", "" } |
| }; |
| |
| for (int i = 0; i < newLineCases.length; i++) { |
| String original = newLineCases[i][0]; |
| String expectedResult = newLineCases[i][1]; |
| assertEquals("chopNewline(String) failed", |
| expectedResult, StringUtils.chopNewline(original)); |
| } |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testRightPad_StringInt() { |
| assertEquals(null, StringUtils.rightPad(null, 5)); |
| assertEquals(" ", StringUtils.rightPad("", 5)); |
| assertEquals("abc ", StringUtils.rightPad("abc", 5)); |
| assertEquals("abc", StringUtils.rightPad("abc", 2)); |
| assertEquals("abc", StringUtils.rightPad("abc", -1)); |
| } |
| |
| public void testRightPad_StringIntChar() { |
| assertEquals(null, StringUtils.rightPad(null, 5, ' ')); |
| assertEquals(" ", StringUtils.rightPad("", 5, ' ')); |
| assertEquals("abc ", StringUtils.rightPad("abc", 5, ' ')); |
| assertEquals("abc", StringUtils.rightPad("abc", 2, ' ')); |
| assertEquals("abc", StringUtils.rightPad("abc", -1, ' ')); |
| assertEquals("abcxx", StringUtils.rightPad("abc", 5, 'x')); |
| String str = StringUtils.rightPad("aaa", 10000, 'a'); // bigger than pad length |
| assertEquals(10000, str.length()); |
| assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'})); |
| } |
| |
| public void testRightPad_StringIntString() { |
| assertEquals(null, StringUtils.rightPad(null, 5, "-+")); |
| assertEquals(" ", StringUtils.rightPad("", 5, " ")); |
| assertEquals(null, StringUtils.rightPad(null, 8, null)); |
| assertEquals("abc-+-+", StringUtils.rightPad("abc", 7, "-+")); |
| assertEquals("abc-+~", StringUtils.rightPad("abc", 6, "-+~")); |
| assertEquals("abc-+", StringUtils.rightPad("abc", 5, "-+~")); |
| assertEquals("abc", StringUtils.rightPad("abc", 2, " ")); |
| assertEquals("abc", StringUtils.rightPad("abc", -1, " ")); |
| assertEquals("abc ", StringUtils.rightPad("abc", 5, null)); |
| assertEquals("abc ", StringUtils.rightPad("abc", 5, "")); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testLeftPad_StringInt() { |
| assertEquals(null, StringUtils.leftPad(null, 5)); |
| assertEquals(" ", StringUtils.leftPad("", 5)); |
| assertEquals(" abc", StringUtils.leftPad("abc", 5)); |
| assertEquals("abc", StringUtils.leftPad("abc", 2)); |
| } |
| |
| public void testLeftPad_StringIntChar() { |
| assertEquals(null, StringUtils.leftPad(null, 5, ' ')); |
| assertEquals(" ", StringUtils.leftPad("", 5, ' ')); |
| assertEquals(" abc", StringUtils.leftPad("abc", 5, ' ')); |
| assertEquals("xxabc", StringUtils.leftPad("abc", 5, 'x')); |
| assertEquals("\uffff\uffffabc", StringUtils.leftPad("abc", 5, '\uffff')); |
| assertEquals("abc", StringUtils.leftPad("abc", 2, ' ')); |
| String str = StringUtils.leftPad("aaa", 10000, 'a'); // bigger than pad length |
| assertEquals(10000, str.length()); |
| assertEquals(true, StringUtils.containsOnly(str, new char[] {'a'})); |
| } |
| |
| public void testLeftPad_StringIntString() { |
| assertEquals(null, StringUtils.leftPad(null, 5, "-+")); |
| assertEquals(null, StringUtils.leftPad(null, 5, null)); |
| assertEquals(" ", StringUtils.leftPad("", 5, " ")); |
| assertEquals("-+-+abc", StringUtils.leftPad("abc", 7, "-+")); |
| assertEquals("-+~abc", StringUtils.leftPad("abc", 6, "-+~")); |
| assertEquals("-+abc", StringUtils.leftPad("abc", 5, "-+~")); |
| assertEquals("abc", StringUtils.leftPad("abc", 2, " ")); |
| assertEquals("abc", StringUtils.leftPad("abc", -1, " ")); |
| assertEquals(" abc", StringUtils.leftPad("abc", 5, null)); |
| assertEquals(" abc", StringUtils.leftPad("abc", 5, "")); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testCenter_StringInt() { |
| assertEquals(null, StringUtils.center(null, -1)); |
| assertEquals(null, StringUtils.center(null, 4)); |
| assertEquals(" ", StringUtils.center("", 4)); |
| assertEquals("ab", StringUtils.center("ab", 0)); |
| assertEquals("ab", StringUtils.center("ab", -1)); |
| assertEquals("ab", StringUtils.center("ab", 1)); |
| assertEquals(" ", StringUtils.center("", 4)); |
| assertEquals(" ab ", StringUtils.center("ab", 4)); |
| assertEquals("abcd", StringUtils.center("abcd", 2)); |
| assertEquals(" a ", StringUtils.center("a", 4)); |
| assertEquals(" a ", StringUtils.center("a", 5)); |
| } |
| |
| public void testCenter_StringIntChar() { |
| assertEquals(null, StringUtils.center(null, -1, ' ')); |
| assertEquals(null, StringUtils.center(null, 4, ' ')); |
| assertEquals(" ", StringUtils.center("", 4, ' ')); |
| assertEquals("ab", StringUtils.center("ab", 0, ' ')); |
| assertEquals("ab", StringUtils.center("ab", -1, ' ')); |
| assertEquals("ab", StringUtils.center("ab", 1, ' ')); |
| assertEquals(" ", StringUtils.center("", 4, ' ')); |
| assertEquals(" ab ", StringUtils.center("ab", 4, ' ')); |
| assertEquals("abcd", StringUtils.center("abcd", 2, ' ')); |
| assertEquals(" a ", StringUtils.center("a", 4, ' ')); |
| assertEquals(" a ", StringUtils.center("a", 5, ' ')); |
| assertEquals("xxaxx", StringUtils.center("a", 5, 'x')); |
| } |
| |
| public void testCenter_StringIntString() { |
| assertEquals(null, StringUtils.center(null, 4, null)); |
| assertEquals(null, StringUtils.center(null, -1, " ")); |
| assertEquals(null, StringUtils.center(null, 4, " ")); |
| assertEquals(" ", StringUtils.center("", 4, " ")); |
| assertEquals("ab", StringUtils.center("ab", 0, " ")); |
| assertEquals("ab", StringUtils.center("ab", -1, " ")); |
| assertEquals("ab", StringUtils.center("ab", 1, " ")); |
| assertEquals(" ", StringUtils.center("", 4, " ")); |
| assertEquals(" ab ", StringUtils.center("ab", 4, " ")); |
| assertEquals("abcd", StringUtils.center("abcd", 2, " ")); |
| assertEquals(" a ", StringUtils.center("a", 4, " ")); |
| assertEquals("yayz", StringUtils.center("a", 4, "yz")); |
| assertEquals("yzyayzy", StringUtils.center("a", 7, "yz")); |
| assertEquals(" abc ", StringUtils.center("abc", 7, null)); |
| assertEquals(" abc ", StringUtils.center("abc", 7, "")); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testReverse_String() { |
| assertEquals(null, StringUtils.reverse(null) ); |
| assertEquals("", StringUtils.reverse("") ); |
| assertEquals("sdrawkcab", StringUtils.reverse("backwards") ); |
| } |
| |
| public void testReverseDelimited_StringChar() { |
| assertEquals(null, 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("", '.') ); |
| } |
| |
| public void testReverseDelimitedString_StringString() { |
| assertEquals(null, StringUtils.reverseDelimitedString(null, null) ); |
| assertEquals("", StringUtils.reverseDelimitedString("", null) ); |
| assertEquals("", StringUtils.reverseDelimitedString("", ".") ); |
| assertEquals("a.b.c", StringUtils.reverseDelimitedString("a.b.c", null) ); |
| assertEquals("c b a", StringUtils.reverseDelimitedString("a b c", null) ); |
| assertEquals("c.b.a", StringUtils.reverseDelimitedString("a.b.c", ".") ); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testDefault_String() { |
| assertEquals("", StringUtils.defaultString(null)); |
| assertEquals("", StringUtils.defaultString("")); |
| assertEquals("abc", StringUtils.defaultString("abc")); |
| } |
| |
| public void testDefault_StringString() { |
| assertEquals("NULL", StringUtils.defaultString(null, "NULL")); |
| assertEquals("", StringUtils.defaultString("", "NULL")); |
| assertEquals("abc", StringUtils.defaultString("abc", "NULL")); |
| } |
| |
| public void testDefaultIfEmpty_StringString() { |
| assertEquals("NULL", StringUtils.defaultIfEmpty(null, "NULL")); |
| assertEquals("NULL", StringUtils.defaultIfEmpty("", "NULL")); |
| assertEquals("abc", StringUtils.defaultIfEmpty("abc", "NULL")); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testEscapeFunctions_String() { |
| assertEquals("", StringUtils.escape("") ); |
| assertEquals("abc", StringUtils.escape("abc") ); |
| assertEquals("\\t", StringUtils.escape("\t") ); |
| assertEquals("\\\\", StringUtils.escape("\\") ); |
| assertEquals("\\\\\\b\\t\\r", StringUtils.escape("\\\b\t\r") ); |
| assertEquals("\\u1234", StringUtils.escape("\u1234") ); |
| assertEquals("\\u0234", StringUtils.escape("\u0234") ); |
| assertEquals("\\u00FD", StringUtils.escape("\u00fd") ); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testAbbreviate_StringInt() { |
| assertEquals(null, StringUtils.abbreviate(null, 10)); |
| assertEquals("", StringUtils.abbreviate("", 10)); |
| assertEquals("short", StringUtils.abbreviate("short", 10)); |
| assertEquals("Now is ...", StringUtils.abbreviate("Now is the time for all good men to come to the aid of their party.", 10)); |
| |
| String raspberry = "raspberry peach"; |
| assertEquals("raspberry p...", StringUtils.abbreviate(raspberry, 14)); |
| assertEquals("raspberry peach", StringUtils.abbreviate("raspberry peach", 15)); |
| assertEquals("raspberry peach", StringUtils.abbreviate("raspberry peach", 16)); |
| assertEquals("abc...", StringUtils.abbreviate("abcdefg", 6)); |
| assertEquals("abcdefg", StringUtils.abbreviate("abcdefg", 7)); |
| assertEquals("abcdefg", StringUtils.abbreviate("abcdefg", 8)); |
| assertEquals("a...", StringUtils.abbreviate("abcdefg", 4)); |
| assertEquals("", StringUtils.abbreviate("", 4)); |
| |
| try { |
| String res = StringUtils.abbreviate("abc", 3); |
| fail("StringUtils.abbreviate expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // empty |
| } |
| } |
| |
| public void testAbbreviate_StringIntInt() { |
| assertEquals(null, StringUtils.abbreviate(null, 10, 12)); |
| assertEquals("", StringUtils.abbreviate("", 0, 10)); |
| assertEquals("", StringUtils.abbreviate("", 2, 10)); |
| |
| try { |
| String res = StringUtils.abbreviate("abcdefghij", 0, 3); |
| fail("StringUtils.abbreviate expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // empty |
| } |
| try { |
| String res = StringUtils.abbreviate("abcdefghij", 5, 6); |
| fail("StringUtils.abbreviate expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // empty |
| } |
| |
| |
| String raspberry = "raspberry peach"; |
| assertEquals("raspberry peach", StringUtils.abbreviate(raspberry, 11, 15)); |
| |
| assertEquals(null, StringUtils.abbreviate(null, 7, 14)); |
| assertAbbreviateWithOffset("abcdefg...", -1, 10); |
| assertAbbreviateWithOffset("abcdefg...", 0, 10); |
| assertAbbreviateWithOffset("abcdefg...", 1, 10); |
| assertAbbreviateWithOffset("abcdefg...", 2, 10); |
| assertAbbreviateWithOffset("abcdefg...", 3, 10); |
| assertAbbreviateWithOffset("abcdefg...", 4, 10); |
| assertAbbreviateWithOffset("...fghi...", 5, 10); |
| assertAbbreviateWithOffset("...ghij...", 6, 10); |
| assertAbbreviateWithOffset("...hijk...", 7, 10); |
| assertAbbreviateWithOffset("...ijklmno", 8, 10); |
| assertAbbreviateWithOffset("...ijklmno", 9, 10); |
| assertAbbreviateWithOffset("...ijklmno", 10, 10); |
| assertAbbreviateWithOffset("...ijklmno", 10, 10); |
| assertAbbreviateWithOffset("...ijklmno", 11, 10); |
| assertAbbreviateWithOffset("...ijklmno", 12, 10); |
| assertAbbreviateWithOffset("...ijklmno", 13, 10); |
| assertAbbreviateWithOffset("...ijklmno", 14, 10); |
| assertAbbreviateWithOffset("...ijklmno", 15, 10); |
| assertAbbreviateWithOffset("...ijklmno", 16, 10); |
| assertAbbreviateWithOffset("...ijklmno", Integer.MAX_VALUE, 10); |
| } |
| |
| private void assertAbbreviateWithOffset(String expected, int offset, int maxWidth) { |
| String abcdefghijklmno = "abcdefghijklmno"; |
| String message = "abbreviate(String,int,int) failed"; |
| 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); |
| } |
| assertTrue(message + " -- should not be greater than maxWidth", |
| actual.length() <= maxWidth); |
| assertEquals(message, expected, actual); |
| } |
| |
| //----------------------------------------------------------------------- |
| public void testDifference_StringString() { |
| assertEquals(null, StringUtils.difference(null, null)); |
| assertEquals("", StringUtils.difference("", "")); |
| assertEquals("abc", StringUtils.difference("", "abc")); |
| assertEquals("", StringUtils.difference("abc", "")); |
| assertEquals("i am a robot", StringUtils.difference(null, "i am a robot")); |
| assertEquals("i am a machine", StringUtils.difference("i am a machine", null)); |
| assertEquals("robot", StringUtils.difference("i am a machine", "i am a robot")); |
| assertEquals("", StringUtils.difference("abc", "abc")); |
| assertEquals("you are a robot", StringUtils.difference("i am a robot", "you are a robot")); |
| } |
| |
| public void testDifferenceAt_StringString() { |
| assertEquals(-1, StringUtils.indexOfDifference(null, null)); |
| assertEquals(0, StringUtils.indexOfDifference(null, "i am a robot")); |
| assertEquals(-1, StringUtils.indexOfDifference("", "")); |
| assertEquals(0, StringUtils.indexOfDifference("", "abc")); |
| assertEquals(0, StringUtils.indexOfDifference("abc", "")); |
| assertEquals(0, StringUtils.indexOfDifference("i am a machine", null)); |
| assertEquals(7, StringUtils.indexOfDifference("i am a machine", "i am a robot")); |
| assertEquals(-1, StringUtils.indexOfDifference("foo", "foo")); |
| assertEquals(0, StringUtils.indexOfDifference("i am a robot", "you are a robot")); |
| //System.out.println("indexOfDiff: " + StringUtils.indexOfDifference("i am a robot", "not machine")); |
| } |
| |
| //----------------------------------------------------------------------- |
| 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") ); |
| try { |
| int d = StringUtils.getLevenshteinDistance("a", null); |
| fail("expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // empty |
| } |
| try { |
| int d = StringUtils.getLevenshteinDistance(null, "a"); |
| fail("expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // empty |
| } |
| } |
| |
| /** |
| * A sanity check for {@link StringUtils.EMPTY}. |
| */ |
| public void testEMPTY() { |
| assertNotNull(StringUtils.EMPTY); |
| assertEquals("", StringUtils.EMPTY); |
| } |
| |
| public void testRemoveStart() { |
| // StringUtils.removeStart("", *) = "" |
| assertNull(StringUtils.removeStart(null, null)); |
| assertNull(StringUtils.removeStart(null, "")); |
| assertNull(StringUtils.removeStart(null, "a")); |
| |
| // StringUtils.removeStart(*, null) = * |
| assertEquals(StringUtils.removeStart("", null), ""); |
| assertEquals(StringUtils.removeStart("", ""), ""); |
| assertEquals(StringUtils.removeStart("", "a"), ""); |
| |
| // All others: |
| assertEquals(StringUtils.removeStart("www.domain.com", "www."), "domain.com"); |
| assertEquals(StringUtils.removeStart("domain.com", "www."), "domain.com"); |
| assertEquals(StringUtils.removeStart("domain.com", ""), "domain.com"); |
| assertEquals(StringUtils.removeStart("domain.com", null), "domain.com"); |
| } |
| |
| public void testRemoveEnd() { |
| // StringUtils.removeEnd("", *) = "" |
| assertNull(StringUtils.removeEnd(null, null)); |
| assertNull(StringUtils.removeEnd(null, "")); |
| assertNull(StringUtils.removeEnd(null, "a")); |
| |
| // StringUtils.removeEnd(*, null) = * |
| assertEquals(StringUtils.removeEnd("", null), ""); |
| assertEquals(StringUtils.removeEnd("", ""), ""); |
| assertEquals(StringUtils.removeEnd("", "a"), ""); |
| |
| // All others: |
| assertEquals(StringUtils.removeEnd("www.domain.com.", ".com"), "www.domain.com."); |
| assertEquals(StringUtils.removeEnd("www.domain.com", ".com"), "www.domain"); |
| assertEquals(StringUtils.removeEnd("www.domain", ".com"), "www.domain"); |
| assertEquals(StringUtils.removeEnd("domain.com", ""), "domain.com"); |
| assertEquals(StringUtils.removeEnd("domain.com", null), "domain.com"); |
| } |
| |
| public void testRemove_String() { |
| // StringUtils.remove(null, *) = null |
| assertEquals(null, StringUtils.remove(null, null)); |
| assertEquals(null, StringUtils.remove(null, "")); |
| assertEquals(null, StringUtils.remove(null, "a")); |
| |
| // StringUtils.remove("", *) = "" |
| assertEquals("", StringUtils.remove("", null)); |
| assertEquals("", StringUtils.remove("", "")); |
| assertEquals("", StringUtils.remove("", "a")); |
| |
| // StringUtils.remove(*, null) = * |
| assertEquals(null, StringUtils.remove(null, null)); |
| assertEquals("", StringUtils.remove("", null)); |
| assertEquals("a", StringUtils.remove("a", null)); |
| |
| // StringUtils.remove(*, "") = * |
| assertEquals(null, StringUtils.remove(null, "")); |
| assertEquals("", StringUtils.remove("", "")); |
| assertEquals("a", StringUtils.remove("a", "")); |
| |
| // StringUtils.remove("queued", "ue") = "qd" |
| assertEquals("qd", StringUtils.remove("queued", "ue")); |
| |
| // StringUtils.remove("queued", "zz") = "queued" |
| assertEquals("queued", StringUtils.remove("queued", "zz")); |
| } |
| |
| public void testRemove_char() { |
| // StringUtils.remove(null, *) = null |
| assertEquals(null, StringUtils.remove(null, 'a')); |
| assertEquals(null, StringUtils.remove(null, 'a')); |
| assertEquals(null, StringUtils.remove(null, 'a')); |
| |
| // StringUtils.remove("", *) = "" |
| assertEquals("", StringUtils.remove("", 'a')); |
| assertEquals("", StringUtils.remove("", 'a')); |
| assertEquals("", StringUtils.remove("", 'a')); |
| |
| // StringUtils.remove("queued", 'u') = "qeed" |
| assertEquals("qeed", StringUtils.remove("queued", 'u')); |
| |
| // StringUtils.remove("queued", 'z') = "queued" |
| assertEquals("queued", StringUtils.remove("queued", 'z')); |
| } |
| |
| } |
