• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 package org.apache.commons.lang3;
18 
19 import static org.apache.commons.lang3.Supplementary.CharU20000;
20 import static org.apache.commons.lang3.Supplementary.CharU20001;
21 import static org.apache.commons.lang3.Supplementary.CharUSuppCharHigh;
22 import static org.apache.commons.lang3.Supplementary.CharUSuppCharLow;
23 import static org.junit.jupiter.api.Assertions.assertEquals;
24 import static org.junit.jupiter.api.Assertions.assertFalse;
25 import static org.junit.jupiter.api.Assertions.assertTrue;
26 
27 import java.util.Locale;
28 
29 import org.junit.jupiter.api.Test;
30 import org.junitpioneer.jupiter.DefaultLocale;
31 
32 /**
33  * Unit tests {@link org.apache.commons.lang3.StringUtils} - Contains methods
34  */
35 public class StringUtilsContainsTest extends AbstractLangTest {
36     @Test
testContains_Char()37     public void testContains_Char() {
38         assertFalse(StringUtils.contains(null, ' '));
39         assertFalse(StringUtils.contains("", ' '));
40         assertFalse(StringUtils.contains("", null));
41         assertFalse(StringUtils.contains(null, null));
42         assertTrue(StringUtils.contains("abc", 'a'));
43         assertTrue(StringUtils.contains("abc", 'b'));
44         assertTrue(StringUtils.contains("abc", 'c'));
45         assertFalse(StringUtils.contains("abc", 'z'));
46     }
47 
48     @Test
testContains_String()49     public void testContains_String() {
50         assertFalse(StringUtils.contains(null, null));
51         assertFalse(StringUtils.contains(null, ""));
52         assertFalse(StringUtils.contains(null, "a"));
53         assertFalse(StringUtils.contains("", null));
54         assertTrue(StringUtils.contains("", ""));
55         assertFalse(StringUtils.contains("", "a"));
56         assertTrue(StringUtils.contains("abc", "a"));
57         assertTrue(StringUtils.contains("abc", "b"));
58         assertTrue(StringUtils.contains("abc", "c"));
59         assertTrue(StringUtils.contains("abc", "abc"));
60         assertFalse(StringUtils.contains("abc", "z"));
61     }
62 
63     /**
64      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
65      */
66     @Test
testContains_StringWithBadSupplementaryChars()67     public void testContains_StringWithBadSupplementaryChars() {
68         // Test edge case: 1/2 of a (broken) supplementary char
69         assertFalse(StringUtils.contains(CharUSuppCharHigh, CharU20001));
70         assertFalse(StringUtils.contains(CharUSuppCharLow, CharU20001));
71         assertFalse(StringUtils.contains(CharU20001, CharUSuppCharHigh));
72         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
73         assertTrue(StringUtils.contains(CharU20001, CharUSuppCharLow));
74         assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
75         assertTrue(StringUtils.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
76     }
77 
78     /**
79      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
80      */
81     @Test
testContains_StringWithSupplementaryChars()82     public void testContains_StringWithSupplementaryChars() {
83         assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20000));
84         assertTrue(StringUtils.contains(CharU20000 + CharU20001, CharU20001));
85         assertTrue(StringUtils.contains(CharU20000, CharU20000));
86         assertFalse(StringUtils.contains(CharU20000, CharU20001));
87     }
88 
89     @Test
testContainsAny_StringCharArray()90     public void testContainsAny_StringCharArray() {
91         assertFalse(StringUtils.containsAny(null, (char[]) null));
92         assertFalse(StringUtils.containsAny(null, new char[0]));
93         assertFalse(StringUtils.containsAny(null, 'a', 'b'));
94 
95         assertFalse(StringUtils.containsAny("", (char[]) null));
96         assertFalse(StringUtils.containsAny("", new char[0]));
97         assertFalse(StringUtils.containsAny("", 'a', 'b'));
98 
99         assertFalse(StringUtils.containsAny("zzabyycdxx", (char[]) null));
100         assertFalse(StringUtils.containsAny("zzabyycdxx", new char[0]));
101         assertTrue(StringUtils.containsAny("zzabyycdxx", 'z', 'a'));
102         assertTrue(StringUtils.containsAny("zzabyycdxx", 'b', 'y'));
103         assertTrue(StringUtils.containsAny("zzabyycdxx", 'z', 'y'));
104         assertFalse(StringUtils.containsAny("ab", 'z'));
105     }
106 
107     /**
108      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
109      */
110     @Test
testContainsAny_StringCharArrayWithBadSupplementaryChars()111     public void testContainsAny_StringCharArrayWithBadSupplementaryChars() {
112         // Test edge case: 1/2 of a (broken) supplementary char
113         assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001.toCharArray()));
114         assertFalse(StringUtils.containsAny("abc" + CharUSuppCharHigh + "xyz", CharU20001.toCharArray()));
115         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
116         assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001.toCharArray()));
117         assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh.toCharArray()));
118         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
119         assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow.toCharArray()));
120     }
121 
122     /**
123      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
124      */
125     @Test
testContainsAny_StringCharArrayWithSupplementaryChars()126     public void testContainsAny_StringCharArrayWithSupplementaryChars() {
127         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
128         assertTrue(StringUtils.containsAny("a" + CharU20000 + CharU20001, "a".toCharArray()));
129         assertTrue(StringUtils.containsAny(CharU20000 + "a" + CharU20001, "a".toCharArray()));
130         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001 + "a", "a".toCharArray()));
131         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
132         assertTrue(StringUtils.containsAny(CharU20000, CharU20000.toCharArray()));
133         // Sanity check:
134         assertEquals(-1, CharU20000.indexOf(CharU20001));
135         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
136         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
137         // Test:
138         assertFalse(StringUtils.containsAny(CharU20000, CharU20001.toCharArray()));
139         assertFalse(StringUtils.containsAny(CharU20001, CharU20000.toCharArray()));
140     }
141 
142     @Test
testContainsAny_StringString()143     public void testContainsAny_StringString() {
144         assertFalse(StringUtils.containsAny(null, (String) null));
145         assertFalse(StringUtils.containsAny(null, ""));
146         assertFalse(StringUtils.containsAny(null, "ab"));
147 
148         assertFalse(StringUtils.containsAny("", (String) null));
149         assertFalse(StringUtils.containsAny("", ""));
150         assertFalse(StringUtils.containsAny("", "ab"));
151 
152         assertFalse(StringUtils.containsAny("zzabyycdxx", (String) null));
153         assertFalse(StringUtils.containsAny("zzabyycdxx", ""));
154         assertTrue(StringUtils.containsAny("zzabyycdxx", "za"));
155         assertTrue(StringUtils.containsAny("zzabyycdxx", "by"));
156         assertTrue(StringUtils.containsAny("zzabyycdxx", "zy"));
157         assertFalse(StringUtils.containsAny("ab", "z"));
158     }
159 
160     @Test
testContainsAny_StringStringArray()161     public void testContainsAny_StringStringArray() {
162         assertFalse(StringUtils.containsAny(null, (String[]) null));
163         assertFalse(StringUtils.containsAny(null, new String[0]));
164         assertFalse(StringUtils.containsAny(null, new String[] { "hello" }));
165         assertFalse(StringUtils.containsAny("", (String[]) null));
166         assertFalse(StringUtils.containsAny("", new String[0]));
167         assertFalse(StringUtils.containsAny("", new String[] { "hello" }));
168         assertFalse(StringUtils.containsAny("hello, goodbye", (String[]) null));
169         assertFalse(StringUtils.containsAny("hello, goodbye", new String[0]));
170         assertTrue(StringUtils.containsAny("hello, goodbye", new String[]{"hello", "goodbye"}));
171         assertTrue(StringUtils.containsAny("hello, goodbye", new String[]{"hello", "Goodbye"}));
172         assertFalse(StringUtils.containsAny("hello, goodbye", new String[]{"Hello", "Goodbye"}));
173         assertFalse(StringUtils.containsAny("hello, goodbye", new String[]{"Hello", null}));
174         assertFalse(StringUtils.containsAny("hello, null", new String[] { "Hello", null }));
175         // Javadoc examples:
176         assertTrue(StringUtils.containsAny("abcd", "ab", null));
177         assertTrue(StringUtils.containsAny("abcd", "ab", "cd"));
178         assertTrue(StringUtils.containsAny("abc", "d", "abc"));
179     }
180 
181     @Test
testContainsAnyIgnoreCase_StringStringArray()182     public void testContainsAnyIgnoreCase_StringStringArray() {
183         assertFalse(StringUtils.containsAnyIgnoreCase(null, (String[]) null));
184         assertFalse(StringUtils.containsAnyIgnoreCase(null, new String[0]));
185         assertFalse(StringUtils.containsAnyIgnoreCase(null, new String[] { "hello" }));
186         assertFalse(StringUtils.containsAnyIgnoreCase("", (String[]) null));
187         assertFalse(StringUtils.containsAnyIgnoreCase("", new String[0]));
188         assertFalse(StringUtils.containsAnyIgnoreCase("", new String[] { "hello" }));
189         assertFalse(StringUtils.containsAnyIgnoreCase("hello, goodbye", (String[]) null));
190         assertFalse(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[0]));
191         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[]{"hello", "goodbye"}));
192         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[]{"hello", "Goodbye"}));
193         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[]{"Hello", "Goodbye"}));
194         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[]{"Hello", null}));
195         assertTrue(StringUtils.containsAnyIgnoreCase("hello, null", new String[] { "Hello", null }));
196         // Javadoc examples:
197         assertTrue(StringUtils.containsAnyIgnoreCase("abcd", "ab", null));
198         assertTrue(StringUtils.containsAnyIgnoreCase("abcd", "ab", "cd"));
199         assertTrue(StringUtils.containsAnyIgnoreCase("abc", "d", "abc"));
200     }
201 
202     /**
203      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
204      */
205     @Test
testContainsAny_StringWithBadSupplementaryChars()206     public void testContainsAny_StringWithBadSupplementaryChars() {
207         // Test edge case: 1/2 of a (broken) supplementary char
208         assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
209         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
210         assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001));
211         assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
212         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
213         assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow));
214     }
215 
216     /**
217      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
218      */
219     @Test
testContainsAny_StringWithSupplementaryChars()220     public void testContainsAny_StringWithSupplementaryChars() {
221         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
222         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
223         assertTrue(StringUtils.containsAny(CharU20000, CharU20000));
224         // Sanity check:
225         assertEquals(-1, CharU20000.indexOf(CharU20001));
226         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
227         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
228         // Test:
229         assertFalse(StringUtils.containsAny(CharU20000, CharU20001));
230         assertFalse(StringUtils.containsAny(CharU20001, CharU20000));
231     }
232 
233     @DefaultLocale(language = "de", country = "DE")
234     @Test
testContainsIgnoreCase_LocaleIndependence()235     public void testContainsIgnoreCase_LocaleIndependence() {
236         final Locale[] locales = { Locale.ENGLISH, new Locale("tr"), Locale.getDefault() };
237 
238         final String[][] tdata = { { "i", "I" }, { "I", "i" }, { "\u03C2", "\u03C3" }, { "\u03A3", "\u03C2" },
239             { "\u03A3", "\u03C3" }, };
240 
241         final String[][] fdata = { { "\u00DF", "SS" }, };
242 
243         for (final Locale testLocale : locales) {
244             Locale.setDefault(testLocale);
245             for (int j = 0; j < tdata.length; j++) {
246                 assertTrue(StringUtils.containsIgnoreCase(tdata[j][0], tdata[j][1]),
247                     Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1]);
248             }
249             for (int j = 0; j < fdata.length; j++) {
250                 assertFalse(StringUtils.containsIgnoreCase(fdata[j][0], fdata[j][1]),
251                     Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1]);
252             }
253         }
254     }
255 
256     @Test
testContainsIgnoreCase_StringString()257     public void testContainsIgnoreCase_StringString() {
258         assertFalse(StringUtils.containsIgnoreCase(null, null));
259 
260         // Null tests
261         assertFalse(StringUtils.containsIgnoreCase(null, ""));
262         assertFalse(StringUtils.containsIgnoreCase(null, "a"));
263         assertFalse(StringUtils.containsIgnoreCase(null, "abc"));
264 
265         assertFalse(StringUtils.containsIgnoreCase("", null));
266         assertFalse(StringUtils.containsIgnoreCase("a", null));
267         assertFalse(StringUtils.containsIgnoreCase("abc", null));
268 
269         // Match len = 0
270         assertTrue(StringUtils.containsIgnoreCase("", ""));
271         assertTrue(StringUtils.containsIgnoreCase("a", ""));
272         assertTrue(StringUtils.containsIgnoreCase("abc", ""));
273 
274         // Match len = 1
275         assertFalse(StringUtils.containsIgnoreCase("", "a"));
276         assertTrue(StringUtils.containsIgnoreCase("a", "a"));
277         assertTrue(StringUtils.containsIgnoreCase("abc", "a"));
278         assertFalse(StringUtils.containsIgnoreCase("", "A"));
279         assertTrue(StringUtils.containsIgnoreCase("a", "A"));
280         assertTrue(StringUtils.containsIgnoreCase("abc", "A"));
281 
282         // Match len > 1
283         assertFalse(StringUtils.containsIgnoreCase("", "abc"));
284         assertFalse(StringUtils.containsIgnoreCase("a", "abc"));
285         assertTrue(StringUtils.containsIgnoreCase("xabcz", "abc"));
286         assertFalse(StringUtils.containsIgnoreCase("", "ABC"));
287         assertFalse(StringUtils.containsIgnoreCase("a", "ABC"));
288         assertTrue(StringUtils.containsIgnoreCase("xabcz", "ABC"));
289     }
290 
291     @Test
testContainsNone_CharArray()292     public void testContainsNone_CharArray() {
293         final String str1 = "a";
294         final String str2 = "b";
295         final String str3 = "ab.";
296         final char[] chars1= {'b'};
297         final char[] chars2= {'.'};
298         final char[] chars3= {'c', 'd'};
299         final char[] emptyChars = {};
300         assertTrue(StringUtils.containsNone(null, (char[]) null));
301         assertTrue(StringUtils.containsNone("", (char[]) null));
302         assertTrue(StringUtils.containsNone(null, emptyChars));
303         assertTrue(StringUtils.containsNone(str1, emptyChars));
304         assertTrue(StringUtils.containsNone("", emptyChars));
305         assertTrue(StringUtils.containsNone("", chars1));
306         assertTrue(StringUtils.containsNone(str1, chars1));
307         assertTrue(StringUtils.containsNone(str1, chars2));
308         assertTrue(StringUtils.containsNone(str1, chars3));
309         assertFalse(StringUtils.containsNone(str2, chars1));
310         assertTrue(StringUtils.containsNone(str2, chars2));
311         assertTrue(StringUtils.containsNone(str2, chars3));
312         assertFalse(StringUtils.containsNone(str3, chars1));
313         assertFalse(StringUtils.containsNone(str3, chars2));
314         assertTrue(StringUtils.containsNone(str3, chars3));
315     }
316 
317     /**
318      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
319      */
320     @Test
testContainsNone_CharArrayWithBadSupplementaryChars()321     public void testContainsNone_CharArrayWithBadSupplementaryChars() {
322         // Test edge case: 1/2 of a (broken) supplementary char
323         assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
324         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
325         assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
326         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
327         assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
328         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
329         assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
330     }
331 
332     /**
333      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
334      */
335     @Test
testContainsNone_CharArrayWithSupplementaryChars()336     public void testContainsNone_CharArrayWithSupplementaryChars() {
337         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
338         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
339         assertFalse(StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
340         // Sanity check:
341         assertEquals(-1, CharU20000.indexOf(CharU20001));
342         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
343         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
344         // Test:
345         assertTrue(StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
346         assertTrue(StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
347     }
348 
349     @Test
testContainsNone_String()350     public void testContainsNone_String() {
351         final String str1 = "a";
352         final String str2 = "b";
353         final String str3 = "ab.";
354         final String chars1= "b";
355         final String chars2= ".";
356         final String chars3= "cd";
357         assertTrue(StringUtils.containsNone(null, (String) null));
358         assertTrue(StringUtils.containsNone("", (String) null));
359         assertTrue(StringUtils.containsNone(null, ""));
360         assertTrue(StringUtils.containsNone(str1, ""));
361         assertTrue(StringUtils.containsNone("", ""));
362         assertTrue(StringUtils.containsNone("", chars1));
363         assertTrue(StringUtils.containsNone(str1, chars1));
364         assertTrue(StringUtils.containsNone(str1, chars2));
365         assertTrue(StringUtils.containsNone(str1, chars3));
366         assertFalse(StringUtils.containsNone(str2, chars1));
367         assertTrue(StringUtils.containsNone(str2, chars2));
368         assertTrue(StringUtils.containsNone(str2, chars3));
369         assertFalse(StringUtils.containsNone(str3, chars1));
370         assertFalse(StringUtils.containsNone(str3, chars2));
371         assertTrue(StringUtils.containsNone(str3, chars3));
372     }
373 
374     /**
375      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
376      */
377     @Test
testContainsNone_StringWithBadSupplementaryChars()378     public void testContainsNone_StringWithBadSupplementaryChars() {
379         // Test edge case: 1/2 of a (broken) supplementary char
380         assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
381         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
382         assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001));
383         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
384         assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
385         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
386         assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow));
387     }
388 
389     /**
390      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
391      */
392     @Test
testContainsNone_StringWithSupplementaryChars()393     public void testContainsNone_StringWithSupplementaryChars() {
394         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
395         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
396         assertFalse(StringUtils.containsNone(CharU20000, CharU20000));
397         // Sanity check:
398         assertEquals(-1, CharU20000.indexOf(CharU20001));
399         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
400         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
401         // Test:
402         assertTrue(StringUtils.containsNone(CharU20000, CharU20001));
403         assertTrue(StringUtils.containsNone(CharU20001, CharU20000));
404     }
405 
406     @Test
testContainsOnly_CharArray()407     public void testContainsOnly_CharArray() {
408         final String str1 = "a";
409         final String str2 = "b";
410         final String str3 = "ab";
411         final char[] chars1= {'b'};
412         final char[] chars2= {'a'};
413         final char[] chars3= {'a', 'b'};
414         final char[] emptyChars = {};
415         assertFalse(StringUtils.containsOnly(null, (char[]) null));
416         assertFalse(StringUtils.containsOnly("", (char[]) null));
417         assertFalse(StringUtils.containsOnly(null, emptyChars));
418         assertFalse(StringUtils.containsOnly(str1, emptyChars));
419         assertTrue(StringUtils.containsOnly("", emptyChars));
420         assertTrue(StringUtils.containsOnly("", chars1));
421         assertFalse(StringUtils.containsOnly(str1, chars1));
422         assertTrue(StringUtils.containsOnly(str1, chars2));
423         assertTrue(StringUtils.containsOnly(str1, chars3));
424         assertTrue(StringUtils.containsOnly(str2, chars1));
425         assertFalse(StringUtils.containsOnly(str2, chars2));
426         assertTrue(StringUtils.containsOnly(str2, chars3));
427         assertFalse(StringUtils.containsOnly(str3, chars1));
428         assertFalse(StringUtils.containsOnly(str3, chars2));
429         assertTrue(StringUtils.containsOnly(str3, chars3));
430     }
431 
432     @Test
testContainsOnly_String()433     public void testContainsOnly_String() {
434         final String str1 = "a";
435         final String str2 = "b";
436         final String str3 = "ab";
437         final String chars1= "b";
438         final String chars2= "a";
439         final String chars3= "ab";
440         assertFalse(StringUtils.containsOnly(null, (String) null));
441         assertFalse(StringUtils.containsOnly("", (String) null));
442         assertFalse(StringUtils.containsOnly(null, ""));
443         assertFalse(StringUtils.containsOnly(str1, ""));
444         assertTrue(StringUtils.containsOnly("", ""));
445         assertTrue(StringUtils.containsOnly("", chars1));
446         assertFalse(StringUtils.containsOnly(str1, chars1));
447         assertTrue(StringUtils.containsOnly(str1, chars2));
448         assertTrue(StringUtils.containsOnly(str1, chars3));
449         assertTrue(StringUtils.containsOnly(str2, chars1));
450         assertFalse(StringUtils.containsOnly(str2, chars2));
451         assertTrue(StringUtils.containsOnly(str2, chars3));
452         assertFalse(StringUtils.containsOnly(str3, chars1));
453         assertFalse(StringUtils.containsOnly(str3, chars2));
454         assertTrue(StringUtils.containsOnly(str3, chars3));
455     }
456 
457     @Test
testContainsWhitespace()458     public void testContainsWhitespace() {
459         assertFalse( StringUtils.containsWhitespace("") );
460         assertTrue( StringUtils.containsWhitespace(" ") );
461         assertFalse( StringUtils.containsWhitespace("a") );
462         assertTrue( StringUtils.containsWhitespace("a ") );
463         assertTrue( StringUtils.containsWhitespace(" a") );
464         assertTrue( StringUtils.containsWhitespace("a\t") );
465         assertTrue( StringUtils.containsWhitespace("\n") );
466     }
467 }
468