You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by pa...@apache.org on 2016/07/31 17:22:35 UTC
[2/2] [lang] reorganize test classes for StringUtils to make it
clearer were tests for a method are located
reorganize test classes for StringUtils to make it clearer were tests for a method are located
Project: http://git-wip-us.apache.org/repos/asf/commons-lang/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-lang/commit/0223a4d4
Tree: http://git-wip-us.apache.org/repos/asf/commons-lang/tree/0223a4d4
Diff: http://git-wip-us.apache.org/repos/asf/commons-lang/diff/0223a4d4
Branch: refs/heads/master
Commit: 0223a4d4cd127a1e209a04d8e1eff3296c0ed8c1
Parents: 009e33b
Author: pascalschumacher <pa...@gmx.net>
Authored: Sun Jul 31 19:20:54 2016 +0200
Committer: pascalschumacher <pa...@gmx.net>
Committed: Sun Jul 31 19:20:54 2016 +0200
----------------------------------------------------------------------
.../commons/lang3/StringUtilsContainsTest.java | 477 +++++++++++++++++++
.../lang3/StringUtilsEmptyBlankTest.java | 114 +++++
.../lang3/StringUtilsEqualsIndexOfTest.java | 434 +----------------
.../apache/commons/lang3/StringUtilsIsTest.java | 4 +-
.../apache/commons/lang3/StringUtilsTest.java | 55 +--
.../commons/lang3/StringUtilsTrimEmptyTest.java | 279 -----------
.../commons/lang3/StringUtilsTrimStripTest.java | 239 ++++++++++
7 files changed, 834 insertions(+), 768 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java
new file mode 100644
index 0000000..6fedb92
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsContainsTest.java
@@ -0,0 +1,477 @@
+/*
+ * 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.lang3;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Locale;
+
+import org.apache.commons.lang3.test.SystemDefaultsSwitch;
+import org.apache.commons.lang3.test.SystemDefaults;
+import org.junit.Rule;
+import org.junit.Test;
+
+/**
+ * Unit tests {@link org.apache.commons.lang3.StringUtils} - Contains methods
+ */
+public class StringUtilsContainsTest {
+
+ @Rule
+ public SystemDefaultsSwitch defaults = new SystemDefaultsSwitch();
+
+ /**
+ * Supplementary character U+20000
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ private static final String CharU20000 = "\uD840\uDC00";
+ /**
+ * Supplementary character U+20001
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ private static final String CharU20001 = "\uD840\uDC01";
+ /**
+ * Incomplete supplementary character U+20000, high surrogate only.
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ private static final String CharUSuppCharHigh = "\uDC00";
+
+ /**
+ * Incomplete supplementary character U+20000, low surrogate only.
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ private static final String CharUSuppCharLow = "\uD840";
+
+ @Test
+ public void testContains_Char() {
+ assertFalse(StringUtils.contains(null, ' '));
+ assertFalse(StringUtils.contains("", ' '));
+ assertFalse(StringUtils.contains("", null));
+ assertFalse(StringUtils.contains(null, null));
+ assertTrue(StringUtils.contains("abc", 'a'));
+ assertTrue(StringUtils.contains("abc", 'b'));
+ assertTrue(StringUtils.contains("abc", 'c'));
+ assertFalse(StringUtils.contains("abc", 'z'));
+ }
+
+ @Test
+ public void testContains_String() {
+ assertFalse(StringUtils.contains(null, null));
+ assertFalse(StringUtils.contains(null, ""));
+ assertFalse(StringUtils.contains(null, "a"));
+ assertFalse(StringUtils.contains("", null));
+ assertTrue(StringUtils.contains("", ""));
+ assertFalse(StringUtils.contains("", "a"));
+ assertTrue(StringUtils.contains("abc", "a"));
+ assertTrue(StringUtils.contains("abc", "b"));
+ assertTrue(StringUtils.contains("abc", "c"));
+ assertTrue(StringUtils.contains("abc", "abc"));
+ assertFalse(StringUtils.contains("abc", "z"));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContains_StringWithBadSupplementaryChars() {
+ // Test edge case: 1/2 of a (broken) supplementary char
+ assertFalse(StringUtils.contains(CharUSuppCharHigh, CharU20001));
+ assertFalse(StringUtils.contains(CharUSuppCharLow, CharU20001));
+ assertFalse(StringUtils.contains(CharU20001, CharUSuppCharHigh));
+ assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
+ assertTrue(StringUtils.contains(CharU20001, CharUSuppCharLow));
+ assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
+ assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContains_StringWithSupplementaryChars() {
+ assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20000));
+ assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20001));
+ assertTrue(StringUtils.contains(CharU20000, CharU20000));
+ assertFalse(StringUtils.contains(CharU20000, CharU20001));
+ }
+
+ @Test
+ public void testContainsAny_StringCharArray() {
+ assertFalse(StringUtils.containsAny(null, (char[]) null));
+ assertFalse(StringUtils.containsAny(null, new char[0]));
+ assertFalse(StringUtils.containsAny(null, 'a', 'b'));
+
+ assertFalse(StringUtils.containsAny("", (char[]) null));
+ assertFalse(StringUtils.containsAny("", new char[0]));
+ assertFalse(StringUtils.containsAny("", 'a', 'b'));
+
+ assertFalse(StringUtils.containsAny("zzabyycdxx", (char[]) null));
+ assertFalse(StringUtils.containsAny("zzabyycdxx", new char[0]));
+ assertTrue(StringUtils.containsAny("zzabyycdxx", 'z', 'a'));
+ assertTrue(StringUtils.containsAny("zzabyycdxx", 'b', 'y'));
+ assertTrue(StringUtils.containsAny("zzabyycdxx", 'z', 'y'));
+ assertFalse(StringUtils.containsAny("ab", 'z'));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsAny_StringCharArrayWithBadSupplementaryChars() {
+ // Test edge case: 1/2 of a (broken) supplementary char
+ assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001.toCharArray()));
+ assertFalse(StringUtils.containsAny("abc" + CharUSuppCharHigh + "xyz", CharU20001.toCharArray()));
+ assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
+ assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001.toCharArray()));
+ assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh.toCharArray()));
+ assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
+ assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow.toCharArray()));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsAny_StringCharArrayWithSupplementaryChars() {
+ assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
+ assertTrue(StringUtils.containsAny("a" + CharU20000 + CharU20001, "a".toCharArray()));
+ assertTrue(StringUtils.containsAny(CharU20000 + "a" + CharU20001, "a".toCharArray()));
+ assertTrue(StringUtils.containsAny(CharU20000 + CharU20001 + "a", "a".toCharArray()));
+ assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
+ assertTrue(StringUtils.containsAny(CharU20000, CharU20000.toCharArray()));
+ // Sanity check:
+ assertEquals(-1, CharU20000.indexOf(CharU20001));
+ assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
+ assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
+ // Test:
+ assertFalse(StringUtils.containsAny(CharU20000, CharU20001.toCharArray()));
+ assertFalse(StringUtils.containsAny(CharU20001, CharU20000.toCharArray()));
+ }
+
+ @Test
+ public void testContainsAny_StringString() {
+ assertFalse(StringUtils.containsAny(null, (String) null));
+ assertFalse(StringUtils.containsAny(null, ""));
+ assertFalse(StringUtils.containsAny(null, "ab"));
+
+ assertFalse(StringUtils.containsAny("", (String) null));
+ assertFalse(StringUtils.containsAny("", ""));
+ assertFalse(StringUtils.containsAny("", "ab"));
+
+ assertFalse(StringUtils.containsAny("zzabyycdxx", (String) null));
+ assertFalse(StringUtils.containsAny("zzabyycdxx", ""));
+ assertTrue(StringUtils.containsAny("zzabyycdxx", "za"));
+ assertTrue(StringUtils.containsAny("zzabyycdxx", "by"));
+ assertTrue(StringUtils.containsAny("zzabyycdxx", "zy"));
+ assertFalse(StringUtils.containsAny("ab", "z"));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsAny_StringWithBadSupplementaryChars() {
+ // Test edge case: 1/2 of a (broken) supplementary char
+ assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
+ assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
+ assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001));
+ assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
+ assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
+ assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsAny_StringWithSupplementaryChars() {
+ assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
+ assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
+ assertTrue(StringUtils.containsAny(CharU20000, CharU20000));
+ // Sanity check:
+ assertEquals(-1, CharU20000.indexOf(CharU20001));
+ assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
+ assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
+ // Test:
+ assertFalse(StringUtils.containsAny(CharU20000, CharU20001));
+ assertFalse(StringUtils.containsAny(CharU20001, CharU20000));
+ }
+
+ @Test
+ public void testContainsAny_StringStringArray() {
+ assertFalse(StringUtils.containsAny(null, (String[]) null));
+ assertFalse(StringUtils.containsAny(null, new String[0]));
+ assertFalse(StringUtils.containsAny(null, new String[] { "hello" }));
+ assertFalse(StringUtils.containsAny("", (String[]) null));
+ assertFalse(StringUtils.containsAny("", new String[0]));
+ assertFalse(StringUtils.containsAny("", new String[] { "hello" }));
+ assertFalse(StringUtils.containsAny("hello, goodbye", (String[]) null));
+ assertFalse(StringUtils.containsAny("hello, goodbye", new String[0]));
+ assertTrue(StringUtils.containsAny("hello, goodbye", new String[]{"hello", "goodbye"}));
+ assertTrue(StringUtils.containsAny("hello, goodbye", new String[]{"hello", "Goodbye"}));
+ assertFalse(StringUtils.containsAny("hello, goodbye", new String[]{"Hello", "Goodbye"}));
+ assertFalse(StringUtils.containsAny("hello, goodbye", new String[]{"Hello", null}));
+ assertFalse(StringUtils.containsAny("hello, null", new String[] { "Hello", null }));
+ // Javadoc examples:
+ assertTrue(StringUtils.containsAny("abcd", "ab", null));
+ assertTrue(StringUtils.containsAny("abcd", "ab", "cd"));
+ assertTrue(StringUtils.containsAny("abc", "d", "abc"));
+ }
+
+ @SystemDefaults(locale="de_DE")
+ @Test
+ public void testContainsIgnoreCase_LocaleIndependence() {
+ final Locale[] locales = { Locale.ENGLISH, new Locale("tr"), Locale.getDefault() };
+
+ final String[][] tdata = {
+ { "i", "I" },
+ { "I", "i" },
+ { "\u03C2", "\u03C3" },
+ { "\u03A3", "\u03C2" },
+ { "\u03A3", "\u03C3" },
+ };
+
+ final String[][] fdata = {
+ { "\u00DF", "SS" },
+ };
+
+ for (final Locale testLocale : locales) {
+ Locale.setDefault(testLocale);
+ for (int j = 0; j < tdata.length; j++) {
+ assertTrue(Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1], StringUtils
+ .containsIgnoreCase(tdata[j][0], tdata[j][1]));
+ }
+ for (int j = 0; j < fdata.length; j++) {
+ assertFalse(Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1], StringUtils
+ .containsIgnoreCase(fdata[j][0], fdata[j][1]));
+ }
+ }
+ }
+
+ @Test
+ public void testContainsIgnoreCase_StringString() {
+ assertFalse(StringUtils.containsIgnoreCase(null, null));
+
+ // Null tests
+ assertFalse(StringUtils.containsIgnoreCase(null, ""));
+ assertFalse(StringUtils.containsIgnoreCase(null, "a"));
+ assertFalse(StringUtils.containsIgnoreCase(null, "abc"));
+
+ assertFalse(StringUtils.containsIgnoreCase("", null));
+ assertFalse(StringUtils.containsIgnoreCase("a", null));
+ assertFalse(StringUtils.containsIgnoreCase("abc", null));
+
+ // Match len = 0
+ assertTrue(StringUtils.containsIgnoreCase("", ""));
+ assertTrue(StringUtils.containsIgnoreCase("a", ""));
+ assertTrue(StringUtils.containsIgnoreCase("abc", ""));
+
+ // Match len = 1
+ assertFalse(StringUtils.containsIgnoreCase("", "a"));
+ assertTrue(StringUtils.containsIgnoreCase("a", "a"));
+ assertTrue(StringUtils.containsIgnoreCase("abc", "a"));
+ assertFalse(StringUtils.containsIgnoreCase("", "A"));
+ assertTrue(StringUtils.containsIgnoreCase("a", "A"));
+ assertTrue(StringUtils.containsIgnoreCase("abc", "A"));
+
+ // Match len > 1
+ assertFalse(StringUtils.containsIgnoreCase("", "abc"));
+ assertFalse(StringUtils.containsIgnoreCase("a", "abc"));
+ assertTrue(StringUtils.containsIgnoreCase("xabcz", "abc"));
+ assertFalse(StringUtils.containsIgnoreCase("", "ABC"));
+ assertFalse(StringUtils.containsIgnoreCase("a", "ABC"));
+ assertTrue(StringUtils.containsIgnoreCase("xabcz", "ABC"));
+ }
+
+ @Test
+ public void testContainsNone_CharArray() {
+ final String str1 = "a";
+ final String str2 = "b";
+ final String str3 = "ab.";
+ final char[] chars1= {'b'};
+ final char[] chars2= {'.'};
+ final char[] chars3= {'c', 'd'};
+ final char[] emptyChars = new char[0];
+ assertTrue(StringUtils.containsNone(null, (char[]) null));
+ assertTrue(StringUtils.containsNone("", (char[]) null));
+ assertTrue(StringUtils.containsNone(null, emptyChars));
+ assertTrue(StringUtils.containsNone(str1, emptyChars));
+ assertTrue(StringUtils.containsNone("", emptyChars));
+ assertTrue(StringUtils.containsNone("", chars1));
+ assertTrue(StringUtils.containsNone(str1, chars1));
+ assertTrue(StringUtils.containsNone(str1, chars2));
+ assertTrue(StringUtils.containsNone(str1, chars3));
+ assertFalse(StringUtils.containsNone(str2, chars1));
+ assertTrue(StringUtils.containsNone(str2, chars2));
+ assertTrue(StringUtils.containsNone(str2, chars3));
+ assertFalse(StringUtils.containsNone(str3, chars1));
+ assertFalse(StringUtils.containsNone(str3, chars2));
+ assertTrue(StringUtils.containsNone(str3, chars3));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsNone_CharArrayWithBadSupplementaryChars() {
+ // Test edge case: 1/2 of a (broken) supplementary char
+ assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
+ assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
+ assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
+ assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
+ assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
+ assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
+ assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsNone_CharArrayWithSupplementaryChars() {
+ assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
+ assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
+ assertFalse(StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
+ // Sanity check:
+ assertEquals(-1, CharU20000.indexOf(CharU20001));
+ assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
+ assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
+ // Test:
+ assertTrue(StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
+ assertTrue(StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
+ }
+
+ @Test
+ public void testContainsNone_String() {
+ final String str1 = "a";
+ final String str2 = "b";
+ final String str3 = "ab.";
+ final String chars1= "b";
+ final String chars2= ".";
+ final String chars3= "cd";
+ assertTrue(StringUtils.containsNone(null, (String) null));
+ assertTrue(StringUtils.containsNone("", (String) null));
+ assertTrue(StringUtils.containsNone(null, ""));
+ assertTrue(StringUtils.containsNone(str1, ""));
+ assertTrue(StringUtils.containsNone("", ""));
+ assertTrue(StringUtils.containsNone("", chars1));
+ assertTrue(StringUtils.containsNone(str1, chars1));
+ assertTrue(StringUtils.containsNone(str1, chars2));
+ assertTrue(StringUtils.containsNone(str1, chars3));
+ assertFalse(StringUtils.containsNone(str2, chars1));
+ assertTrue(StringUtils.containsNone(str2, chars2));
+ assertTrue(StringUtils.containsNone(str2, chars3));
+ assertFalse(StringUtils.containsNone(str3, chars1));
+ assertFalse(StringUtils.containsNone(str3, chars2));
+ assertTrue(StringUtils.containsNone(str3, chars3));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsNone_StringWithBadSupplementaryChars() {
+ // Test edge case: 1/2 of a (broken) supplementary char
+ assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
+ assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
+ assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001));
+ assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
+ assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
+ assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
+ assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow));
+ }
+
+ /**
+ * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
+ */
+ @Test
+ public void testContainsNone_StringWithSupplementaryChars() {
+ assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
+ assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
+ assertFalse(StringUtils.containsNone(CharU20000, CharU20000));
+ // Sanity check:
+ assertEquals(-1, CharU20000.indexOf(CharU20001));
+ assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
+ assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
+ // Test:
+ assertTrue(StringUtils.containsNone(CharU20000, CharU20001));
+ assertTrue(StringUtils.containsNone(CharU20001, CharU20000));
+ }
+
+ @Test
+ public void testContainsOnly_CharArray() {
+ final String str1 = "a";
+ final String str2 = "b";
+ final String str3 = "ab";
+ final char[] chars1= {'b'};
+ final char[] chars2= {'a'};
+ final char[] chars3= {'a', 'b'};
+ final char[] emptyChars = new char[0];
+ assertFalse(StringUtils.containsOnly(null, (char[]) null));
+ assertFalse(StringUtils.containsOnly("", (char[]) null));
+ assertFalse(StringUtils.containsOnly(null, emptyChars));
+ assertFalse(StringUtils.containsOnly(str1, emptyChars));
+ assertTrue(StringUtils.containsOnly("", emptyChars));
+ assertTrue(StringUtils.containsOnly("", chars1));
+ assertFalse(StringUtils.containsOnly(str1, chars1));
+ assertTrue(StringUtils.containsOnly(str1, chars2));
+ assertTrue(StringUtils.containsOnly(str1, chars3));
+ assertTrue(StringUtils.containsOnly(str2, chars1));
+ assertFalse(StringUtils.containsOnly(str2, chars2));
+ assertTrue(StringUtils.containsOnly(str2, chars3));
+ assertFalse(StringUtils.containsOnly(str3, chars1));
+ assertFalse(StringUtils.containsOnly(str3, chars2));
+ assertTrue(StringUtils.containsOnly(str3, chars3));
+ }
+
+ @Test
+ public void testContainsOnly_String() {
+ final String str1 = "a";
+ final String str2 = "b";
+ final String str3 = "ab";
+ final String chars1= "b";
+ final String chars2= "a";
+ final String chars3= "ab";
+ assertFalse(StringUtils.containsOnly(null, (String) null));
+ assertFalse(StringUtils.containsOnly("", (String) null));
+ assertFalse(StringUtils.containsOnly(null, ""));
+ assertFalse(StringUtils.containsOnly(str1, ""));
+ assertTrue(StringUtils.containsOnly("", ""));
+ assertTrue(StringUtils.containsOnly("", chars1));
+ assertFalse(StringUtils.containsOnly(str1, chars1));
+ assertTrue(StringUtils.containsOnly(str1, chars2));
+ assertTrue(StringUtils.containsOnly(str1, chars3));
+ assertTrue(StringUtils.containsOnly(str2, chars1));
+ assertFalse(StringUtils.containsOnly(str2, chars2));
+ assertTrue(StringUtils.containsOnly(str2, chars3));
+ assertFalse(StringUtils.containsOnly(str3, chars1));
+ assertFalse(StringUtils.containsOnly(str3, chars2));
+ assertTrue(StringUtils.containsOnly(str3, chars3));
+ }
+
+ @Test
+ public void testContainsWhitespace() {
+ assertFalse( StringUtils.containsWhitespace("") );
+ assertTrue( StringUtils.containsWhitespace(" ") );
+ assertFalse( StringUtils.containsWhitespace("a") );
+ assertTrue( StringUtils.containsWhitespace("a ") );
+ assertTrue( StringUtils.containsWhitespace(" a") );
+ assertTrue( StringUtils.containsWhitespace("a\t") );
+ assertTrue( StringUtils.containsWhitespace("\n") );
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java
new file mode 100644
index 0000000..b3d33fc
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsEmptyBlankTest.java
@@ -0,0 +1,114 @@
+/*
+ * 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.lang3;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+/**
+ * Unit tests {@link org.apache.commons.lang3.StringUtils} - Empty/Blank methods
+ */
+public class StringUtilsEmptyBlankTest {
+
+ @Test
+ public void testIsEmpty() {
+ assertTrue(StringUtils.isEmpty(null));
+ assertTrue(StringUtils.isEmpty(""));
+ assertFalse(StringUtils.isEmpty(" "));
+ assertFalse(StringUtils.isEmpty("foo"));
+ assertFalse(StringUtils.isEmpty(" foo "));
+ }
+
+ @Test
+ public void testIsNotEmpty() {
+ assertFalse(StringUtils.isNotEmpty(null));
+ assertFalse(StringUtils.isNotEmpty(""));
+ assertTrue(StringUtils.isNotEmpty(" "));
+ assertTrue(StringUtils.isNotEmpty("foo"));
+ assertTrue(StringUtils.isNotEmpty(" foo "));
+ }
+
+ @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(StringUtilsTest.WHITESPACE));
+ assertFalse(StringUtils.isBlank("foo"));
+ assertFalse(StringUtils.isBlank(" foo "));
+ }
+
+ @Test
+ public void testIsNotBlank() {
+ assertFalse(StringUtils.isNotBlank(null));
+ assertFalse(StringUtils.isNotBlank(""));
+ assertFalse(StringUtils.isNotBlank(StringUtilsTest.WHITESPACE));
+ assertTrue(StringUtils.isNotBlank("foo"));
+ assertTrue(StringUtils.isNotBlank(" foo "));
+ }
+
+ @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"));
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
index 93a1dfc..9014bfa 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
@@ -21,16 +21,13 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
-import java.util.Locale;
-
import org.apache.commons.lang3.test.SystemDefaultsSwitch;
-import org.apache.commons.lang3.test.SystemDefaults;
import org.hamcrest.core.IsNot;
import org.junit.Rule;
import org.junit.Test;
/**
- * Unit tests {@link org.apache.commons.lang3.StringUtils} - Substring methods
+ * Unit tests {@link org.apache.commons.lang3.StringUtils} - Equals/IndexOf methods
*/
public class StringUtilsEqualsIndexOfTest {
@@ -48,17 +45,6 @@ public class StringUtilsEqualsIndexOfTest {
* See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
*/
private static final String CharU20001 = "\uD840\uDC01";
- /**
- * Incomplete supplementary character U+20000, high surrogate only.
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- private static final String CharUSuppCharHigh = "\uDC00";
-
- /**
- * Incomplete supplementary character U+20000, low surrogate only.
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- private static final String CharUSuppCharLow = "\uD840";
private static final String FOO = "foo";
@@ -66,424 +52,6 @@ public class StringUtilsEqualsIndexOfTest {
private static final String[] FOOBAR_SUB_ARRAY = new String[] {"ob", "ba"};
- @Test
- public void testContains_Char() {
- assertFalse(StringUtils.contains(null, ' '));
- assertFalse(StringUtils.contains("", ' '));
- assertFalse(StringUtils.contains("", null));
- assertFalse(StringUtils.contains(null, null));
- assertTrue(StringUtils.contains("abc", 'a'));
- assertTrue(StringUtils.contains("abc", 'b'));
- assertTrue(StringUtils.contains("abc", 'c'));
- assertFalse(StringUtils.contains("abc", 'z'));
- }
-
- @Test
- public void testContains_String() {
- assertFalse(StringUtils.contains(null, null));
- assertFalse(StringUtils.contains(null, ""));
- assertFalse(StringUtils.contains(null, "a"));
- assertFalse(StringUtils.contains("", null));
- assertTrue(StringUtils.contains("", ""));
- assertFalse(StringUtils.contains("", "a"));
- assertTrue(StringUtils.contains("abc", "a"));
- assertTrue(StringUtils.contains("abc", "b"));
- assertTrue(StringUtils.contains("abc", "c"));
- assertTrue(StringUtils.contains("abc", "abc"));
- assertFalse(StringUtils.contains("abc", "z"));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContains_StringWithBadSupplementaryChars() {
- // Test edge case: 1/2 of a (broken) supplementary char
- assertFalse(StringUtils.contains(CharUSuppCharHigh, CharU20001));
- assertFalse(StringUtils.contains(CharUSuppCharLow, CharU20001));
- assertFalse(StringUtils.contains(CharU20001, CharUSuppCharHigh));
- assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
- assertTrue(StringUtils.contains(CharU20001, CharUSuppCharLow));
- assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
- assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContains_StringWithSupplementaryChars() {
- assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20000));
- assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20001));
- assertTrue(StringUtils.contains(CharU20000, CharU20000));
- assertFalse(StringUtils.contains(CharU20000, CharU20001));
- }
-
- @Test
- public void testContainsAny_StringCharArray() {
- assertFalse(StringUtils.containsAny(null, (char[]) null));
- assertFalse(StringUtils.containsAny(null, new char[0]));
- assertFalse(StringUtils.containsAny(null, 'a', 'b'));
-
- assertFalse(StringUtils.containsAny("", (char[]) null));
- assertFalse(StringUtils.containsAny("", new char[0]));
- assertFalse(StringUtils.containsAny("", 'a', 'b'));
-
- assertFalse(StringUtils.containsAny("zzabyycdxx", (char[]) null));
- assertFalse(StringUtils.containsAny("zzabyycdxx", new char[0]));
- assertTrue(StringUtils.containsAny("zzabyycdxx", 'z', 'a'));
- assertTrue(StringUtils.containsAny("zzabyycdxx", 'b', 'y'));
- assertTrue(StringUtils.containsAny("zzabyycdxx", 'z', 'y'));
- assertFalse(StringUtils.containsAny("ab", 'z'));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsAny_StringCharArrayWithBadSupplementaryChars() {
- // Test edge case: 1/2 of a (broken) supplementary char
- assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001.toCharArray()));
- assertFalse(StringUtils.containsAny("abc" + CharUSuppCharHigh + "xyz", CharU20001.toCharArray()));
- assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
- assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001.toCharArray()));
- assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh.toCharArray()));
- assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
- assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow.toCharArray()));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsAny_StringCharArrayWithSupplementaryChars() {
- assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
- assertTrue(StringUtils.containsAny("a" + CharU20000 + CharU20001, "a".toCharArray()));
- assertTrue(StringUtils.containsAny(CharU20000 + "a" + CharU20001, "a".toCharArray()));
- assertTrue(StringUtils.containsAny(CharU20000 + CharU20001 + "a", "a".toCharArray()));
- assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
- assertTrue(StringUtils.containsAny(CharU20000, CharU20000.toCharArray()));
- // Sanity check:
- assertEquals(-1, CharU20000.indexOf(CharU20001));
- assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
- assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
- // Test:
- assertFalse(StringUtils.containsAny(CharU20000, CharU20001.toCharArray()));
- assertFalse(StringUtils.containsAny(CharU20001, CharU20000.toCharArray()));
- }
-
- @Test
- public void testContainsAny_StringString() {
- assertFalse(StringUtils.containsAny(null, (String) null));
- assertFalse(StringUtils.containsAny(null, ""));
- assertFalse(StringUtils.containsAny(null, "ab"));
-
- assertFalse(StringUtils.containsAny("", (String) null));
- assertFalse(StringUtils.containsAny("", ""));
- assertFalse(StringUtils.containsAny("", "ab"));
-
- assertFalse(StringUtils.containsAny("zzabyycdxx", (String) null));
- assertFalse(StringUtils.containsAny("zzabyycdxx", ""));
- assertTrue(StringUtils.containsAny("zzabyycdxx", "za"));
- assertTrue(StringUtils.containsAny("zzabyycdxx", "by"));
- assertTrue(StringUtils.containsAny("zzabyycdxx", "zy"));
- assertFalse(StringUtils.containsAny("ab", "z"));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsAny_StringWithBadSupplementaryChars() {
- // Test edge case: 1/2 of a (broken) supplementary char
- assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
- assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
- assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001));
- assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
- assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
- assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsAny_StringWithSupplementaryChars() {
- assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
- assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
- assertTrue(StringUtils.containsAny(CharU20000, CharU20000));
- // Sanity check:
- assertEquals(-1, CharU20000.indexOf(CharU20001));
- assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
- assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
- // Test:
- assertFalse(StringUtils.containsAny(CharU20000, CharU20001));
- assertFalse(StringUtils.containsAny(CharU20001, CharU20000));
- }
-
- @Test
- public void testContainsAny_StringStringArray() {
- assertFalse(StringUtils.containsAny(null, (String[]) null));
- assertFalse(StringUtils.containsAny(null, new String[0]));
- assertFalse(StringUtils.containsAny(null, new String[] { "hello" }));
- assertFalse(StringUtils.containsAny("", (String[]) null));
- assertFalse(StringUtils.containsAny("", new String[0]));
- assertFalse(StringUtils.containsAny("", new String[] { "hello" }));
- assertFalse(StringUtils.containsAny("hello, goodbye", (String[]) null));
- assertFalse(StringUtils.containsAny("hello, goodbye", new String[0]));
- assertTrue(StringUtils.containsAny("hello, goodbye", new String[]{"hello", "goodbye"}));
- assertTrue(StringUtils.containsAny("hello, goodbye", new String[]{"hello", "Goodbye"}));
- assertFalse(StringUtils.containsAny("hello, goodbye", new String[]{"Hello", "Goodbye"}));
- assertFalse(StringUtils.containsAny("hello, goodbye", new String[]{"Hello", null}));
- assertFalse(StringUtils.containsAny("hello, null", new String[] { "Hello", null }));
- // Javadoc examples:
- assertTrue(StringUtils.containsAny("abcd", "ab", null));
- assertTrue(StringUtils.containsAny("abcd", "ab", "cd"));
- assertTrue(StringUtils.containsAny("abc", "d", "abc"));
- }
-
- @SystemDefaults(locale="de_DE")
- @Test
- public void testContainsIgnoreCase_LocaleIndependence() {
- final Locale[] locales = { Locale.ENGLISH, new Locale("tr"), Locale.getDefault() };
-
- final String[][] tdata = {
- { "i", "I" },
- { "I", "i" },
- { "\u03C2", "\u03C3" },
- { "\u03A3", "\u03C2" },
- { "\u03A3", "\u03C3" },
- };
-
- final String[][] fdata = {
- { "\u00DF", "SS" },
- };
-
- for (final Locale testLocale : locales) {
- Locale.setDefault(testLocale);
- for (int j = 0; j < tdata.length; j++) {
- assertTrue(Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1], StringUtils
- .containsIgnoreCase(tdata[j][0], tdata[j][1]));
- }
- for (int j = 0; j < fdata.length; j++) {
- assertFalse(Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1], StringUtils
- .containsIgnoreCase(fdata[j][0], fdata[j][1]));
- }
- }
- }
-
- @Test
- public void testContainsIgnoreCase_StringString() {
- assertFalse(StringUtils.containsIgnoreCase(null, null));
-
- // Null tests
- assertFalse(StringUtils.containsIgnoreCase(null, ""));
- assertFalse(StringUtils.containsIgnoreCase(null, "a"));
- assertFalse(StringUtils.containsIgnoreCase(null, "abc"));
-
- assertFalse(StringUtils.containsIgnoreCase("", null));
- assertFalse(StringUtils.containsIgnoreCase("a", null));
- assertFalse(StringUtils.containsIgnoreCase("abc", null));
-
- // Match len = 0
- assertTrue(StringUtils.containsIgnoreCase("", ""));
- assertTrue(StringUtils.containsIgnoreCase("a", ""));
- assertTrue(StringUtils.containsIgnoreCase("abc", ""));
-
- // Match len = 1
- assertFalse(StringUtils.containsIgnoreCase("", "a"));
- assertTrue(StringUtils.containsIgnoreCase("a", "a"));
- assertTrue(StringUtils.containsIgnoreCase("abc", "a"));
- assertFalse(StringUtils.containsIgnoreCase("", "A"));
- assertTrue(StringUtils.containsIgnoreCase("a", "A"));
- assertTrue(StringUtils.containsIgnoreCase("abc", "A"));
-
- // Match len > 1
- assertFalse(StringUtils.containsIgnoreCase("", "abc"));
- assertFalse(StringUtils.containsIgnoreCase("a", "abc"));
- assertTrue(StringUtils.containsIgnoreCase("xabcz", "abc"));
- assertFalse(StringUtils.containsIgnoreCase("", "ABC"));
- assertFalse(StringUtils.containsIgnoreCase("a", "ABC"));
- assertTrue(StringUtils.containsIgnoreCase("xabcz", "ABC"));
- }
-
- @Test
- public void testContainsNone_CharArray() {
- final String str1 = "a";
- final String str2 = "b";
- final String str3 = "ab.";
- final char[] chars1= {'b'};
- final char[] chars2= {'.'};
- final char[] chars3= {'c', 'd'};
- final char[] emptyChars = new char[0];
- assertTrue(StringUtils.containsNone(null, (char[]) null));
- assertTrue(StringUtils.containsNone("", (char[]) null));
- assertTrue(StringUtils.containsNone(null, emptyChars));
- assertTrue(StringUtils.containsNone(str1, emptyChars));
- assertTrue(StringUtils.containsNone("", emptyChars));
- assertTrue(StringUtils.containsNone("", chars1));
- assertTrue(StringUtils.containsNone(str1, chars1));
- assertTrue(StringUtils.containsNone(str1, chars2));
- assertTrue(StringUtils.containsNone(str1, chars3));
- assertFalse(StringUtils.containsNone(str2, chars1));
- assertTrue(StringUtils.containsNone(str2, chars2));
- assertTrue(StringUtils.containsNone(str2, chars3));
- assertFalse(StringUtils.containsNone(str3, chars1));
- assertFalse(StringUtils.containsNone(str3, chars2));
- assertTrue(StringUtils.containsNone(str3, chars3));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsNone_CharArrayWithBadSupplementaryChars() {
- // Test edge case: 1/2 of a (broken) supplementary char
- assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
- assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
- assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
- assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
- assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
- assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
- assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsNone_CharArrayWithSupplementaryChars() {
- assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
- assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
- assertFalse(StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
- // Sanity check:
- assertEquals(-1, CharU20000.indexOf(CharU20001));
- assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
- assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
- // Test:
- assertTrue(StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
- assertTrue(StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
- }
-
- @Test
- public void testContainsNone_String() {
- final String str1 = "a";
- final String str2 = "b";
- final String str3 = "ab.";
- final String chars1= "b";
- final String chars2= ".";
- final String chars3= "cd";
- assertTrue(StringUtils.containsNone(null, (String) null));
- assertTrue(StringUtils.containsNone("", (String) null));
- assertTrue(StringUtils.containsNone(null, ""));
- assertTrue(StringUtils.containsNone(str1, ""));
- assertTrue(StringUtils.containsNone("", ""));
- assertTrue(StringUtils.containsNone("", chars1));
- assertTrue(StringUtils.containsNone(str1, chars1));
- assertTrue(StringUtils.containsNone(str1, chars2));
- assertTrue(StringUtils.containsNone(str1, chars3));
- assertFalse(StringUtils.containsNone(str2, chars1));
- assertTrue(StringUtils.containsNone(str2, chars2));
- assertTrue(StringUtils.containsNone(str2, chars3));
- assertFalse(StringUtils.containsNone(str3, chars1));
- assertFalse(StringUtils.containsNone(str3, chars2));
- assertTrue(StringUtils.containsNone(str3, chars3));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsNone_StringWithBadSupplementaryChars() {
- // Test edge case: 1/2 of a (broken) supplementary char
- assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
- assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
- assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001));
- assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
- assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
- assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
- assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow));
- }
-
- /**
- * See http://www.oracle.com/technetwork/articles/javase/supplementary-142654.html
- */
- @Test
- public void testContainsNone_StringWithSupplementaryChars() {
- assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
- assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
- assertFalse(StringUtils.containsNone(CharU20000, CharU20000));
- // Sanity check:
- assertEquals(-1, CharU20000.indexOf(CharU20001));
- assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
- assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
- // Test:
- assertTrue(StringUtils.containsNone(CharU20000, CharU20001));
- assertTrue(StringUtils.containsNone(CharU20001, CharU20000));
- }
-
- @Test
- public void testContainsOnly_CharArray() {
- final String str1 = "a";
- final String str2 = "b";
- final String str3 = "ab";
- final char[] chars1= {'b'};
- final char[] chars2= {'a'};
- final char[] chars3= {'a', 'b'};
- final char[] emptyChars = new char[0];
- assertFalse(StringUtils.containsOnly(null, (char[]) null));
- assertFalse(StringUtils.containsOnly("", (char[]) null));
- assertFalse(StringUtils.containsOnly(null, emptyChars));
- assertFalse(StringUtils.containsOnly(str1, emptyChars));
- assertTrue(StringUtils.containsOnly("", emptyChars));
- assertTrue(StringUtils.containsOnly("", chars1));
- assertFalse(StringUtils.containsOnly(str1, chars1));
- assertTrue(StringUtils.containsOnly(str1, chars2));
- assertTrue(StringUtils.containsOnly(str1, chars3));
- assertTrue(StringUtils.containsOnly(str2, chars1));
- assertFalse(StringUtils.containsOnly(str2, chars2));
- assertTrue(StringUtils.containsOnly(str2, chars3));
- assertFalse(StringUtils.containsOnly(str3, chars1));
- assertFalse(StringUtils.containsOnly(str3, chars2));
- assertTrue(StringUtils.containsOnly(str3, chars3));
- }
-
- @Test
- public void testContainsOnly_String() {
- final String str1 = "a";
- final String str2 = "b";
- final String str3 = "ab";
- final String chars1= "b";
- final String chars2= "a";
- final String chars3= "ab";
- assertFalse(StringUtils.containsOnly(null, (String) null));
- assertFalse(StringUtils.containsOnly("", (String) null));
- assertFalse(StringUtils.containsOnly(null, ""));
- assertFalse(StringUtils.containsOnly(str1, ""));
- assertTrue(StringUtils.containsOnly("", ""));
- assertTrue(StringUtils.containsOnly("", chars1));
- assertFalse(StringUtils.containsOnly(str1, chars1));
- assertTrue(StringUtils.containsOnly(str1, chars2));
- assertTrue(StringUtils.containsOnly(str1, chars3));
- assertTrue(StringUtils.containsOnly(str2, chars1));
- assertFalse(StringUtils.containsOnly(str2, chars2));
- assertTrue(StringUtils.containsOnly(str2, chars3));
- assertFalse(StringUtils.containsOnly(str3, chars1));
- assertFalse(StringUtils.containsOnly(str3, chars2));
- assertTrue(StringUtils.containsOnly(str3, chars3));
- }
-
- @Test
- public void testContainsWhitespace() {
- assertFalse( StringUtils.containsWhitespace("") );
- assertTrue( StringUtils.containsWhitespace(" ") );
- assertFalse( StringUtils.containsWhitespace("a") );
- assertTrue( StringUtils.containsWhitespace("a ") );
- assertTrue( StringUtils.containsWhitespace(" a") );
- assertTrue( StringUtils.containsWhitespace("a\t") );
- assertTrue( StringUtils.containsWhitespace("\n") );
- }
-
// The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence)
// with a CharSequence implementation whose equals(Object) override requires that the
// other object be an instance of CustomCharSequence, even though, as char sequences,
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
index 9f918d1..6932afb 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
@@ -22,12 +22,10 @@ import static org.junit.Assert.assertTrue;
import org.junit.Test;
/**
- * Unit tests {@link org.apache.commons.lang3.StringUtils} - Substring methods
+ * Unit tests {@link org.apache.commons.lang3.StringUtils} - IsX methods
*/
public class StringUtilsIsTest {
- //-----------------------------------------------------------------------
-
@Test
public void testIsAlpha() {
assertFalse(StringUtils.isAlpha(null));
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/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 5ef73fe..a5c7bbb 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
@@ -41,7 +41,8 @@ import org.apache.commons.lang3.text.WordUtils;
import org.junit.Test;
/**
- * Unit tests {@link org.apache.commons.lang3.StringUtils}.
+ * Unit tests for methods of {@link org.apache.commons.lang3.StringUtils}
+ * which been moved to their own test classes.
*/
@SuppressWarnings("deprecation") // deliberate use of deprecated code
public class StringUtilsTest {
@@ -123,58 +124,6 @@ public class StringUtilsTest {
assertFalse(Modifier.isFinal(StringUtils.class.getModifiers()));
}
- //-----------------------------------------------------------------------
-
- @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 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 testUpperCase() {
assertNull(StringUtils.upperCase(null));
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
deleted file mode 100644
index f55b28f..0000000
--- a/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
+++ /dev/null
@@ -1,279 +0,0 @@
-/*
- * 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.lang3;
-
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-import org.junit.Test;
-
-/**
- * Unit tests {@link org.apache.commons.lang3.StringUtils} - Trim/Empty methods
- */
-public class StringUtilsTrimEmptyTest {
- private static final String FOO = "foo";
-
- //-----------------------------------------------------------------------
- @Test
- public void testIsEmpty() {
- assertTrue(StringUtils.isEmpty(null));
- assertTrue(StringUtils.isEmpty(""));
- assertFalse(StringUtils.isEmpty(" "));
- assertFalse(StringUtils.isEmpty("foo"));
- assertFalse(StringUtils.isEmpty(" foo "));
- }
-
- @Test
- public void testIsNotEmpty() {
- assertFalse(StringUtils.isNotEmpty(null));
- assertFalse(StringUtils.isNotEmpty(""));
- assertTrue(StringUtils.isNotEmpty(" "));
- assertTrue(StringUtils.isNotEmpty("foo"));
- assertTrue(StringUtils.isNotEmpty(" foo "));
- }
-
- @Test
- public void testIsBlank() {
- assertTrue(StringUtils.isBlank(null));
- assertTrue(StringUtils.isBlank(""));
- assertTrue(StringUtils.isBlank(StringUtilsTest.WHITESPACE));
- assertFalse(StringUtils.isBlank("foo"));
- assertFalse(StringUtils.isBlank(" foo "));
- }
-
- @Test
- public void testIsNotBlank() {
- assertFalse(StringUtils.isNotBlank(null));
- assertFalse(StringUtils.isNotBlank(""));
- assertFalse(StringUtils.isNotBlank(StringUtilsTest.WHITESPACE));
- assertTrue(StringUtils.isNotBlank("foo"));
- assertTrue(StringUtils.isNotBlank(" foo "));
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void testTrim() {
- assertEquals(FOO, StringUtils.trim(FOO + " "));
- assertEquals(FOO, StringUtils.trim(" " + FOO + " "));
- assertEquals(FOO, StringUtils.trim(" " + FOO));
- assertEquals(FOO, StringUtils.trim(FOO + ""));
- assertEquals("", StringUtils.trim(" \t\r\n\b "));
- assertEquals("", StringUtils.trim(StringUtilsTest.TRIMMABLE));
- assertEquals(StringUtilsTest.NON_TRIMMABLE, StringUtils.trim(StringUtilsTest.NON_TRIMMABLE));
- assertEquals("", StringUtils.trim(""));
- assertEquals(null, StringUtils.trim(null));
- }
-
- @Test
- public void testTrimToNull() {
- assertEquals(FOO, StringUtils.trimToNull(FOO + " "));
- assertEquals(FOO, StringUtils.trimToNull(" " + FOO + " "));
- assertEquals(FOO, StringUtils.trimToNull(" " + FOO));
- assertEquals(FOO, StringUtils.trimToNull(FOO + ""));
- assertEquals(null, StringUtils.trimToNull(" \t\r\n\b "));
- assertEquals(null, StringUtils.trimToNull(StringUtilsTest.TRIMMABLE));
- assertEquals(StringUtilsTest.NON_TRIMMABLE, StringUtils.trimToNull(StringUtilsTest.NON_TRIMMABLE));
- assertEquals(null, StringUtils.trimToNull(""));
- assertEquals(null, StringUtils.trimToNull(null));
- }
-
- @Test
- public void testTrimToEmpty() {
- assertEquals(FOO, StringUtils.trimToEmpty(FOO + " "));
- assertEquals(FOO, StringUtils.trimToEmpty(" " + FOO + " "));
- assertEquals(FOO, StringUtils.trimToEmpty(" " + FOO));
- assertEquals(FOO, StringUtils.trimToEmpty(FOO + ""));
- assertEquals("", StringUtils.trimToEmpty(" \t\r\n\b "));
- assertEquals("", StringUtils.trimToEmpty(StringUtilsTest.TRIMMABLE));
- assertEquals(StringUtilsTest.NON_TRIMMABLE, StringUtils.trimToEmpty(StringUtilsTest.NON_TRIMMABLE));
- assertEquals("", StringUtils.trimToEmpty(""));
- assertEquals("", StringUtils.trimToEmpty(null));
- }
-
- //-----------------------------------------------------------------------
- @Test
- public void testStrip_String() {
- assertEquals(null, StringUtils.strip(null));
- assertEquals("", StringUtils.strip(""));
- assertEquals("", StringUtils.strip(" "));
- assertEquals("abc", StringUtils.strip(" abc "));
- assertEquals(StringUtilsTest.NON_WHITESPACE,
- StringUtils.strip(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE));
- }
-
- @Test
- public void testStripToNull_String() {
- assertEquals(null, StringUtils.stripToNull(null));
- assertEquals(null, StringUtils.stripToNull(""));
- assertEquals(null, StringUtils.stripToNull(" "));
- assertEquals(null, StringUtils.stripToNull(StringUtilsTest.WHITESPACE));
- assertEquals("ab c", StringUtils.stripToNull(" ab c "));
- assertEquals(StringUtilsTest.NON_WHITESPACE,
- StringUtils.stripToNull(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE));
- }
-
- @Test
- public void testStripToEmpty_String() {
- assertEquals("", StringUtils.stripToEmpty(null));
- assertEquals("", StringUtils.stripToEmpty(""));
- assertEquals("", StringUtils.stripToEmpty(" "));
- assertEquals("", StringUtils.stripToEmpty(StringUtilsTest.WHITESPACE));
- assertEquals("ab c", StringUtils.stripToEmpty(" ab c "));
- assertEquals(StringUtilsTest.NON_WHITESPACE,
- StringUtils.stripToEmpty(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE));
- }
-
- @Test
- public void testStrip_StringString() {
- // null strip
- assertEquals(null, StringUtils.strip(null, null));
- assertEquals("", StringUtils.strip("", null));
- assertEquals("", StringUtils.strip(" ", null));
- assertEquals("abc", StringUtils.strip(" abc ", null));
- assertEquals(StringUtilsTest.NON_WHITESPACE,
- StringUtils.strip(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE, null));
-
- // "" strip
- assertEquals(null, StringUtils.strip(null, ""));
- assertEquals("", StringUtils.strip("", ""));
- assertEquals(" ", StringUtils.strip(" ", ""));
- assertEquals(" abc ", StringUtils.strip(" abc ", ""));
- assertEquals(StringUtilsTest.WHITESPACE, StringUtils.strip(StringUtilsTest.WHITESPACE, ""));
-
- // " " strip
- assertEquals(null, StringUtils.strip(null, " "));
- assertEquals("", StringUtils.strip("", " "));
- assertEquals("", StringUtils.strip(" ", " "));
- assertEquals("abc", StringUtils.strip(" abc ", " "));
-
- // "ab" strip
- assertEquals(null, StringUtils.strip(null, "ab"));
- assertEquals("", StringUtils.strip("", "ab"));
- assertEquals(" ", StringUtils.strip(" ", "ab"));
- assertEquals(" abc ", StringUtils.strip(" abc ", "ab"));
- assertEquals("c", StringUtils.strip("abcabab", "ab"));
- assertEquals(StringUtilsTest.WHITESPACE, StringUtils.strip(StringUtilsTest.WHITESPACE, ""));
- }
-
- @Test
- public void testStripStart_StringString() {
- // null stripStart
- assertEquals(null, StringUtils.stripStart(null, null));
- assertEquals("", StringUtils.stripStart("", null));
- assertEquals("", StringUtils.stripStart(" ", null));
- assertEquals("abc ", StringUtils.stripStart(" abc ", null));
- assertEquals(StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE,
- StringUtils.stripStart(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE, null));
-
- // "" stripStart
- assertEquals(null, StringUtils.stripStart(null, ""));
- assertEquals("", StringUtils.stripStart("", ""));
- assertEquals(" ", StringUtils.stripStart(" ", ""));
- assertEquals(" abc ", StringUtils.stripStart(" abc ", ""));
- assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripStart(StringUtilsTest.WHITESPACE, ""));
-
- // " " stripStart
- assertEquals(null, StringUtils.stripStart(null, " "));
- assertEquals("", StringUtils.stripStart("", " "));
- assertEquals("", StringUtils.stripStart(" ", " "));
- assertEquals("abc ", StringUtils.stripStart(" abc ", " "));
-
- // "ab" stripStart
- assertEquals(null, StringUtils.stripStart(null, "ab"));
- assertEquals("", StringUtils.stripStart("", "ab"));
- assertEquals(" ", StringUtils.stripStart(" ", "ab"));
- assertEquals(" abc ", StringUtils.stripStart(" abc ", "ab"));
- assertEquals("cabab", StringUtils.stripStart("abcabab", "ab"));
- assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripStart(StringUtilsTest.WHITESPACE, ""));
- }
-
- @Test
- public void testStripEnd_StringString() {
- // null stripEnd
- assertEquals(null, StringUtils.stripEnd(null, null));
- assertEquals("", StringUtils.stripEnd("", null));
- assertEquals("", StringUtils.stripEnd(" ", null));
- assertEquals(" abc", StringUtils.stripEnd(" abc ", null));
- assertEquals(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE,
- StringUtils.stripEnd(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE, null));
-
- // "" stripEnd
- assertEquals(null, StringUtils.stripEnd(null, ""));
- assertEquals("", StringUtils.stripEnd("", ""));
- assertEquals(" ", StringUtils.stripEnd(" ", ""));
- assertEquals(" abc ", StringUtils.stripEnd(" abc ", ""));
- assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripEnd(StringUtilsTest.WHITESPACE, ""));
-
- // " " stripEnd
- assertEquals(null, StringUtils.stripEnd(null, " "));
- assertEquals("", StringUtils.stripEnd("", " "));
- assertEquals("", StringUtils.stripEnd(" ", " "));
- assertEquals(" abc", StringUtils.stripEnd(" abc ", " "));
-
- // "ab" stripEnd
- assertEquals(null, StringUtils.stripEnd(null, "ab"));
- assertEquals("", StringUtils.stripEnd("", "ab"));
- assertEquals(" ", StringUtils.stripEnd(" ", "ab"));
- assertEquals(" abc ", StringUtils.stripEnd(" abc ", "ab"));
- assertEquals("abc", StringUtils.stripEnd("abcabab", "ab"));
- assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripEnd(StringUtilsTest.WHITESPACE, ""));
- }
-
- @Test
- public void testStripAll() {
- // test stripAll method, merely an array version of the above strip
- final String[] empty = new String[0];
- final String[] fooSpace = new String[] { " "+FOO+" ", " "+FOO, FOO+" " };
- final String[] fooDots = new String[] { ".."+FOO+"..", ".."+FOO, FOO+".." };
- final String[] foo = new String[] { FOO, FOO, FOO };
-
- assertNull(StringUtils.stripAll((String[]) null));
- // Additional varargs tests
- assertArrayEquals(empty, StringUtils.stripAll()); // empty array
- assertArrayEquals(new String[]{null}, StringUtils.stripAll((String) null)); // == new String[]{null}
-
- assertArrayEquals(empty, StringUtils.stripAll(empty));
- assertArrayEquals(foo, StringUtils.stripAll(fooSpace));
-
- assertNull(StringUtils.stripAll(null, null));
- assertArrayEquals(foo, StringUtils.stripAll(fooSpace, null));
- assertArrayEquals(foo, StringUtils.stripAll(fooDots, "."));
- }
-
- @Test
- public void testStripAccents() {
- final String cue = "\u00C7\u00FA\u00EA";
- assertEquals( "Failed to strip accents from " + cue, "Cue", StringUtils.stripAccents(cue));
-
- final String lots = "\u00C0\u00C1\u00C2\u00C3\u00C4\u00C5\u00C7\u00C8\u00C9" +
- "\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF\u00D1\u00D2\u00D3" +
- "\u00D4\u00D5\u00D6\u00D9\u00DA\u00DB\u00DC\u00DD";
- assertEquals( "Failed to strip accents from " + lots,
- "AAAAAACEEEEIIIINOOOOOUUUUY",
- StringUtils.stripAccents(lots));
-
- assertNull( "Failed null safety", StringUtils.stripAccents(null) );
- assertEquals( "Failed empty String", "", StringUtils.stripAccents("") );
- assertEquals( "Failed to handle non-accented text", "control", StringUtils.stripAccents("control") );
- assertEquals( "Failed to handle easy example", "eclair", StringUtils.stripAccents("\u00E9clair") );
- assertEquals("ALOSZZCN aloszzcn", StringUtils.stripAccents("\u0104\u0141\u00D3\u015A\u017B\u0179\u0106\u0143 "
- + "\u0105\u0142\u00F3\u015B\u017C\u017A\u0107\u0144"));
- }
-}
http://git-wip-us.apache.org/repos/asf/commons-lang/blob/0223a4d4/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
new file mode 100644
index 0000000..1a558f5
--- /dev/null
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
@@ -0,0 +1,239 @@
+/*
+ * 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.lang3;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+
+/**
+ * Unit tests {@link org.apache.commons.lang3.StringUtils} - Trim/Strip methods
+ */
+public class StringUtilsTrimStripTest {
+ private static final String FOO = "foo";
+
+ @Test
+ public void testTrim() {
+ assertEquals(FOO, StringUtils.trim(FOO + " "));
+ assertEquals(FOO, StringUtils.trim(" " + FOO + " "));
+ assertEquals(FOO, StringUtils.trim(" " + FOO));
+ assertEquals(FOO, StringUtils.trim(FOO + ""));
+ assertEquals("", StringUtils.trim(" \t\r\n\b "));
+ assertEquals("", StringUtils.trim(StringUtilsTest.TRIMMABLE));
+ assertEquals(StringUtilsTest.NON_TRIMMABLE, StringUtils.trim(StringUtilsTest.NON_TRIMMABLE));
+ assertEquals("", StringUtils.trim(""));
+ assertEquals(null, StringUtils.trim(null));
+ }
+
+ @Test
+ public void testTrimToNull() {
+ assertEquals(FOO, StringUtils.trimToNull(FOO + " "));
+ assertEquals(FOO, StringUtils.trimToNull(" " + FOO + " "));
+ assertEquals(FOO, StringUtils.trimToNull(" " + FOO));
+ assertEquals(FOO, StringUtils.trimToNull(FOO + ""));
+ assertEquals(null, StringUtils.trimToNull(" \t\r\n\b "));
+ assertEquals(null, StringUtils.trimToNull(StringUtilsTest.TRIMMABLE));
+ assertEquals(StringUtilsTest.NON_TRIMMABLE, StringUtils.trimToNull(StringUtilsTest.NON_TRIMMABLE));
+ assertEquals(null, StringUtils.trimToNull(""));
+ assertEquals(null, StringUtils.trimToNull(null));
+ }
+
+ @Test
+ public void testTrimToEmpty() {
+ assertEquals(FOO, StringUtils.trimToEmpty(FOO + " "));
+ assertEquals(FOO, StringUtils.trimToEmpty(" " + FOO + " "));
+ assertEquals(FOO, StringUtils.trimToEmpty(" " + FOO));
+ assertEquals(FOO, StringUtils.trimToEmpty(FOO + ""));
+ assertEquals("", StringUtils.trimToEmpty(" \t\r\n\b "));
+ assertEquals("", StringUtils.trimToEmpty(StringUtilsTest.TRIMMABLE));
+ assertEquals(StringUtilsTest.NON_TRIMMABLE, StringUtils.trimToEmpty(StringUtilsTest.NON_TRIMMABLE));
+ assertEquals("", StringUtils.trimToEmpty(""));
+ assertEquals("", StringUtils.trimToEmpty(null));
+ }
+
+ //-----------------------------------------------------------------------
+ @Test
+ public void testStrip_String() {
+ assertEquals(null, StringUtils.strip(null));
+ assertEquals("", StringUtils.strip(""));
+ assertEquals("", StringUtils.strip(" "));
+ assertEquals("abc", StringUtils.strip(" abc "));
+ assertEquals(StringUtilsTest.NON_WHITESPACE,
+ StringUtils.strip(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE));
+ }
+
+ @Test
+ public void testStripToNull_String() {
+ assertEquals(null, StringUtils.stripToNull(null));
+ assertEquals(null, StringUtils.stripToNull(""));
+ assertEquals(null, StringUtils.stripToNull(" "));
+ assertEquals(null, StringUtils.stripToNull(StringUtilsTest.WHITESPACE));
+ assertEquals("ab c", StringUtils.stripToNull(" ab c "));
+ assertEquals(StringUtilsTest.NON_WHITESPACE,
+ StringUtils.stripToNull(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE));
+ }
+
+ @Test
+ public void testStripToEmpty_String() {
+ assertEquals("", StringUtils.stripToEmpty(null));
+ assertEquals("", StringUtils.stripToEmpty(""));
+ assertEquals("", StringUtils.stripToEmpty(" "));
+ assertEquals("", StringUtils.stripToEmpty(StringUtilsTest.WHITESPACE));
+ assertEquals("ab c", StringUtils.stripToEmpty(" ab c "));
+ assertEquals(StringUtilsTest.NON_WHITESPACE,
+ StringUtils.stripToEmpty(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE));
+ }
+
+ @Test
+ public void testStrip_StringString() {
+ // null strip
+ assertEquals(null, StringUtils.strip(null, null));
+ assertEquals("", StringUtils.strip("", null));
+ assertEquals("", StringUtils.strip(" ", null));
+ assertEquals("abc", StringUtils.strip(" abc ", null));
+ assertEquals(StringUtilsTest.NON_WHITESPACE,
+ StringUtils.strip(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE, null));
+
+ // "" strip
+ assertEquals(null, StringUtils.strip(null, ""));
+ assertEquals("", StringUtils.strip("", ""));
+ assertEquals(" ", StringUtils.strip(" ", ""));
+ assertEquals(" abc ", StringUtils.strip(" abc ", ""));
+ assertEquals(StringUtilsTest.WHITESPACE, StringUtils.strip(StringUtilsTest.WHITESPACE, ""));
+
+ // " " strip
+ assertEquals(null, StringUtils.strip(null, " "));
+ assertEquals("", StringUtils.strip("", " "));
+ assertEquals("", StringUtils.strip(" ", " "));
+ assertEquals("abc", StringUtils.strip(" abc ", " "));
+
+ // "ab" strip
+ assertEquals(null, StringUtils.strip(null, "ab"));
+ assertEquals("", StringUtils.strip("", "ab"));
+ assertEquals(" ", StringUtils.strip(" ", "ab"));
+ assertEquals(" abc ", StringUtils.strip(" abc ", "ab"));
+ assertEquals("c", StringUtils.strip("abcabab", "ab"));
+ assertEquals(StringUtilsTest.WHITESPACE, StringUtils.strip(StringUtilsTest.WHITESPACE, ""));
+ }
+
+ @Test
+ public void testStripStart_StringString() {
+ // null stripStart
+ assertEquals(null, StringUtils.stripStart(null, null));
+ assertEquals("", StringUtils.stripStart("", null));
+ assertEquals("", StringUtils.stripStart(" ", null));
+ assertEquals("abc ", StringUtils.stripStart(" abc ", null));
+ assertEquals(StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE,
+ StringUtils.stripStart(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE, null));
+
+ // "" stripStart
+ assertEquals(null, StringUtils.stripStart(null, ""));
+ assertEquals("", StringUtils.stripStart("", ""));
+ assertEquals(" ", StringUtils.stripStart(" ", ""));
+ assertEquals(" abc ", StringUtils.stripStart(" abc ", ""));
+ assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripStart(StringUtilsTest.WHITESPACE, ""));
+
+ // " " stripStart
+ assertEquals(null, StringUtils.stripStart(null, " "));
+ assertEquals("", StringUtils.stripStart("", " "));
+ assertEquals("", StringUtils.stripStart(" ", " "));
+ assertEquals("abc ", StringUtils.stripStart(" abc ", " "));
+
+ // "ab" stripStart
+ assertEquals(null, StringUtils.stripStart(null, "ab"));
+ assertEquals("", StringUtils.stripStart("", "ab"));
+ assertEquals(" ", StringUtils.stripStart(" ", "ab"));
+ assertEquals(" abc ", StringUtils.stripStart(" abc ", "ab"));
+ assertEquals("cabab", StringUtils.stripStart("abcabab", "ab"));
+ assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripStart(StringUtilsTest.WHITESPACE, ""));
+ }
+
+ @Test
+ public void testStripEnd_StringString() {
+ // null stripEnd
+ assertEquals(null, StringUtils.stripEnd(null, null));
+ assertEquals("", StringUtils.stripEnd("", null));
+ assertEquals("", StringUtils.stripEnd(" ", null));
+ assertEquals(" abc", StringUtils.stripEnd(" abc ", null));
+ assertEquals(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE,
+ StringUtils.stripEnd(StringUtilsTest.WHITESPACE + StringUtilsTest.NON_WHITESPACE + StringUtilsTest.WHITESPACE, null));
+
+ // "" stripEnd
+ assertEquals(null, StringUtils.stripEnd(null, ""));
+ assertEquals("", StringUtils.stripEnd("", ""));
+ assertEquals(" ", StringUtils.stripEnd(" ", ""));
+ assertEquals(" abc ", StringUtils.stripEnd(" abc ", ""));
+ assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripEnd(StringUtilsTest.WHITESPACE, ""));
+
+ // " " stripEnd
+ assertEquals(null, StringUtils.stripEnd(null, " "));
+ assertEquals("", StringUtils.stripEnd("", " "));
+ assertEquals("", StringUtils.stripEnd(" ", " "));
+ assertEquals(" abc", StringUtils.stripEnd(" abc ", " "));
+
+ // "ab" stripEnd
+ assertEquals(null, StringUtils.stripEnd(null, "ab"));
+ assertEquals("", StringUtils.stripEnd("", "ab"));
+ assertEquals(" ", StringUtils.stripEnd(" ", "ab"));
+ assertEquals(" abc ", StringUtils.stripEnd(" abc ", "ab"));
+ assertEquals("abc", StringUtils.stripEnd("abcabab", "ab"));
+ assertEquals(StringUtilsTest.WHITESPACE, StringUtils.stripEnd(StringUtilsTest.WHITESPACE, ""));
+ }
+
+ @Test
+ public void testStripAll() {
+ // test stripAll method, merely an array version of the above strip
+ final String[] empty = new String[0];
+ final String[] fooSpace = new String[] { " "+FOO+" ", " "+FOO, FOO+" " };
+ final String[] fooDots = new String[] { ".."+FOO+"..", ".."+FOO, FOO+".." };
+ final String[] foo = new String[] { FOO, FOO, FOO };
+
+ assertNull(StringUtils.stripAll((String[]) null));
+ // Additional varargs tests
+ assertArrayEquals(empty, StringUtils.stripAll()); // empty array
+ assertArrayEquals(new String[]{null}, StringUtils.stripAll((String) null)); // == new String[]{null}
+
+ assertArrayEquals(empty, StringUtils.stripAll(empty));
+ assertArrayEquals(foo, StringUtils.stripAll(fooSpace));
+
+ assertNull(StringUtils.stripAll(null, null));
+ assertArrayEquals(foo, StringUtils.stripAll(fooSpace, null));
+ assertArrayEquals(foo, StringUtils.stripAll(fooDots, "."));
+ }
+
+ @Test
+ public void testStripAccents() {
+ final String cue = "\u00C7\u00FA\u00EA";
+ assertEquals( "Failed to strip accents from " + cue, "Cue", StringUtils.stripAccents(cue));
+
+ final String lots = "\u00C0\u00C1\u00C2\u00C3\u00C4\u00C5\u00C7\u00C8\u00C9" +
+ "\u00CA\u00CB\u00CC\u00CD\u00CE\u00CF\u00D1\u00D2\u00D3" +
+ "\u00D4\u00D5\u00D6\u00D9\u00DA\u00DB\u00DC\u00DD";
+ assertEquals( "Failed to strip accents from " + lots,
+ "AAAAAACEEEEIIIINOOOOOUUUUY",
+ StringUtils.stripAccents(lots));
+
+ assertNull( "Failed null safety", StringUtils.stripAccents(null) );
+ assertEquals( "Failed empty String", "", StringUtils.stripAccents("") );
+ assertEquals( "Failed to handle non-accented text", "control", StringUtils.stripAccents("control") );
+ assertEquals( "Failed to handle easy example", "eclair", StringUtils.stripAccents("\u00E9clair") );
+ assertEquals("ALOSZZCN aloszzcn", StringUtils.stripAccents("\u0104\u0141\u00D3\u015A\u017B\u0179\u0106\u0143 "
+ + "\u0105\u0142\u00F3\u015B\u017C\u017A\u0107\u0144"));
+ }
+}