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 000000000..6fedb92ca
--- /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") );
+    }
+}
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 000000000..b3d33fc24
--- /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"));
+    }
+}
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsEqualsIndexOfTest.java
index 93a1dfc87..9014bfa9e 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.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,
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsIsTest.java
index 9f918d1a4..6932afb46 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 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));
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTest.java
index 5ef73fec8..a5c7bbb93 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.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 void testConstructor() {
         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));
diff --git a/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
similarity index 88%
rename from src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
rename to src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
index f55b28fb8..1a558f584 100644
--- a/src/test/java/org/apache/commons/lang3/StringUtilsTrimEmptyTest.java
+++ b/src/test/java/org/apache/commons/lang3/StringUtilsTrimStripTest.java
@@ -18,56 +18,16 @@
 
 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
+ * Unit tests {@link org.apache.commons.lang3.StringUtils} - Trim/Strip methods
  */
-public class StringUtilsTrimEmptyTest  {
+public class StringUtilsTrimStripTest  {
     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 + "  "));