View Javadoc
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 StringUtils} - Contains methods
34   */
35  public class StringUtilsContainsTest extends AbstractLangTest {
36      @Test
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
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
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
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
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
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
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
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
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     /**
182      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
183      */
184     @Test
185     public void testContainsAny_StringWithBadSupplementaryChars() {
186         // Test edge case: 1/2 of a (broken) supplementary char
187         assertFalse(StringUtils.containsAny(CharUSuppCharHigh, CharU20001));
188         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
189         assertFalse(StringUtils.containsAny(CharUSuppCharLow, CharU20001));
190         assertFalse(StringUtils.containsAny(CharU20001, CharUSuppCharHigh));
191         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
192         assertTrue(StringUtils.containsAny(CharU20001, CharUSuppCharLow));
193     }
194 
195     /**
196      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
197      */
198     @Test
199     public void testContainsAny_StringWithSupplementaryChars() {
200         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20000));
201         assertTrue(StringUtils.containsAny(CharU20000 + CharU20001, CharU20001));
202         assertTrue(StringUtils.containsAny(CharU20000, CharU20000));
203         // Sanity check:
204         assertEquals(-1, CharU20000.indexOf(CharU20001));
205         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
206         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
207         // Test:
208         assertFalse(StringUtils.containsAny(CharU20000, CharU20001));
209         assertFalse(StringUtils.containsAny(CharU20001, CharU20000));
210     }
211 
212     @Test
213     public void testContainsAnyIgnoreCase_StringStringArray() {
214         assertFalse(StringUtils.containsAnyIgnoreCase(null, (String[]) null));
215         assertFalse(StringUtils.containsAnyIgnoreCase(null, new String[0]));
216         assertFalse(StringUtils.containsAnyIgnoreCase(null, new String[] { "hello" }));
217         assertFalse(StringUtils.containsAnyIgnoreCase("", (String[]) null));
218         assertFalse(StringUtils.containsAnyIgnoreCase("", new String[0]));
219         assertFalse(StringUtils.containsAnyIgnoreCase("", new String[] { "hello" }));
220         assertFalse(StringUtils.containsAnyIgnoreCase("hello, goodbye", (String[]) null));
221         assertFalse(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[0]));
222         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[] { "hello", "goodbye" }));
223         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[] { "hello", "Goodbye" }));
224         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[] { "Hello", "Goodbye" }));
225         assertTrue(StringUtils.containsAnyIgnoreCase("hello, goodbye", new String[] { "Hello", null }));
226         assertTrue(StringUtils.containsAnyIgnoreCase("hello, null", new String[] { "Hello", null }));
227         // Javadoc examples:
228         assertTrue(StringUtils.containsAnyIgnoreCase("abcd", "ab", null));
229         assertTrue(StringUtils.containsAnyIgnoreCase("abcd", "ab", "cd"));
230         assertTrue(StringUtils.containsAnyIgnoreCase("abc", "d", "abc"));
231     }
232 
233     @DefaultLocale(language = "de", country = "DE")
234     @Test
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" }, { "\u03A3", "\u03C3" }, };
239 
240         final String[][] fdata = { { "\u00DF", "SS" }, };
241 
242         for (final Locale testLocale : locales) {
243             Locale.setDefault(testLocale);
244             for (int j = 0; j < tdata.length; j++) {
245                 assertTrue(StringUtils.containsIgnoreCase(tdata[j][0], tdata[j][1]), Locale.getDefault() + ": " + j + " " + tdata[j][0] + " " + tdata[j][1]);
246             }
247             for (int j = 0; j < fdata.length; j++) {
248                 assertFalse(StringUtils.containsIgnoreCase(fdata[j][0], fdata[j][1]), Locale.getDefault() + ": " + j + " " + fdata[j][0] + " " + fdata[j][1]);
249             }
250         }
251     }
252 
253     @Test
254     public void testContainsIgnoreCase_StringString() {
255         assertFalse(StringUtils.containsIgnoreCase(null, null));
256 
257         // Null tests
258         assertFalse(StringUtils.containsIgnoreCase(null, ""));
259         assertFalse(StringUtils.containsIgnoreCase(null, "a"));
260         assertFalse(StringUtils.containsIgnoreCase(null, "abc"));
261 
262         assertFalse(StringUtils.containsIgnoreCase("", null));
263         assertFalse(StringUtils.containsIgnoreCase("a", null));
264         assertFalse(StringUtils.containsIgnoreCase("abc", null));
265 
266         // Match len = 0
267         assertTrue(StringUtils.containsIgnoreCase("", ""));
268         assertTrue(StringUtils.containsIgnoreCase("a", ""));
269         assertTrue(StringUtils.containsIgnoreCase("abc", ""));
270 
271         // Match len = 1
272         assertFalse(StringUtils.containsIgnoreCase("", "a"));
273         assertTrue(StringUtils.containsIgnoreCase("a", "a"));
274         assertTrue(StringUtils.containsIgnoreCase("abc", "a"));
275         assertFalse(StringUtils.containsIgnoreCase("", "A"));
276         assertTrue(StringUtils.containsIgnoreCase("a", "A"));
277         assertTrue(StringUtils.containsIgnoreCase("abc", "A"));
278 
279         // Match len > 1
280         assertFalse(StringUtils.containsIgnoreCase("", "abc"));
281         assertFalse(StringUtils.containsIgnoreCase("a", "abc"));
282         assertTrue(StringUtils.containsIgnoreCase("xabcz", "abc"));
283         assertFalse(StringUtils.containsIgnoreCase("", "ABC"));
284         assertFalse(StringUtils.containsIgnoreCase("a", "ABC"));
285         assertTrue(StringUtils.containsIgnoreCase("xabcz", "ABC"));
286     }
287 
288     @Test
289     public void testContainsNone_CharArray() {
290         final String str1 = "a";
291         final String str2 = "b";
292         final String str3 = "ab.";
293         final char[] chars1 = { 'b' };
294         final char[] chars2 = { '.' };
295         final char[] chars3 = { 'c', 'd' };
296         final char[] emptyChars = {};
297         assertTrue(StringUtils.containsNone(null, (char[]) null));
298         assertTrue(StringUtils.containsNone("", (char[]) null));
299         assertTrue(StringUtils.containsNone(null, emptyChars));
300         assertTrue(StringUtils.containsNone(str1, emptyChars));
301         assertTrue(StringUtils.containsNone("", emptyChars));
302         assertTrue(StringUtils.containsNone("", chars1));
303         assertTrue(StringUtils.containsNone(str1, chars1));
304         assertTrue(StringUtils.containsNone(str1, chars2));
305         assertTrue(StringUtils.containsNone(str1, chars3));
306         assertFalse(StringUtils.containsNone(str2, chars1));
307         assertTrue(StringUtils.containsNone(str2, chars2));
308         assertTrue(StringUtils.containsNone(str2, chars3));
309         assertFalse(StringUtils.containsNone(str3, chars1));
310         assertFalse(StringUtils.containsNone(str3, chars2));
311         assertTrue(StringUtils.containsNone(str3, chars3));
312     }
313 
314     /**
315      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
316      */
317     @Test
318     public void testContainsNone_CharArrayWithBadSupplementaryChars() {
319         // Test edge case: 1/2 of a (broken) supplementary char
320         assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
321         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
322         assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
323         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
324         assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
325         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
326         assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
327     }
328 
329     /**
330      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
331      */
332     @Test
333     public void testContainsNone_CharArrayWithSupplementaryChars() {
334         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
335         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
336         assertFalse(StringUtils.containsNone(CharU20000, CharU20000.toCharArray()));
337         // Sanity check:
338         assertEquals(-1, CharU20000.indexOf(CharU20001));
339         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
340         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
341         // Test:
342         assertTrue(StringUtils.containsNone(CharU20000, CharU20001.toCharArray()));
343         assertTrue(StringUtils.containsNone(CharU20001, CharU20000.toCharArray()));
344     }
345 
346     @Test
347     public void testContainsNone_String() {
348         final String str1 = "a";
349         final String str2 = "b";
350         final String str3 = "ab.";
351         final String chars1 = "b";
352         final String chars2 = ".";
353         final String chars3 = "cd";
354         assertTrue(StringUtils.containsNone(null, (String) null));
355         assertTrue(StringUtils.containsNone("", (String) null));
356         assertTrue(StringUtils.containsNone(null, ""));
357         assertTrue(StringUtils.containsNone(str1, ""));
358         assertTrue(StringUtils.containsNone("", ""));
359         assertTrue(StringUtils.containsNone("", chars1));
360         assertTrue(StringUtils.containsNone(str1, chars1));
361         assertTrue(StringUtils.containsNone(str1, chars2));
362         assertTrue(StringUtils.containsNone(str1, chars3));
363         assertFalse(StringUtils.containsNone(str2, chars1));
364         assertTrue(StringUtils.containsNone(str2, chars2));
365         assertTrue(StringUtils.containsNone(str2, chars3));
366         assertFalse(StringUtils.containsNone(str3, chars1));
367         assertFalse(StringUtils.containsNone(str3, chars2));
368         assertTrue(StringUtils.containsNone(str3, chars3));
369     }
370 
371     /**
372      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
373      */
374     @Test
375     public void testContainsNone_StringWithBadSupplementaryChars() {
376         // Test edge case: 1/2 of a (broken) supplementary char
377         assertTrue(StringUtils.containsNone(CharUSuppCharHigh, CharU20001));
378         assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
379         assertTrue(StringUtils.containsNone(CharUSuppCharLow, CharU20001));
380         assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
381         assertTrue(StringUtils.containsNone(CharU20001, CharUSuppCharHigh));
382         assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
383         assertFalse(StringUtils.containsNone(CharU20001, CharUSuppCharLow));
384     }
385 
386     /**
387      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
388      */
389     @Test
390     public void testContainsNone_StringWithSupplementaryChars() {
391         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20000));
392         assertFalse(StringUtils.containsNone(CharU20000 + CharU20001, CharU20001));
393         assertFalse(StringUtils.containsNone(CharU20000, CharU20000));
394         // Sanity check:
395         assertEquals(-1, CharU20000.indexOf(CharU20001));
396         assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
397         assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
398         // Test:
399         assertTrue(StringUtils.containsNone(CharU20000, CharU20001));
400         assertTrue(StringUtils.containsNone(CharU20001, CharU20000));
401     }
402 
403     @Test
404     public void testContainsOnly_CharArray() {
405         final String str1 = "a";
406         final String str2 = "b";
407         final String str3 = "ab";
408         final char[] chars1 = { 'b' };
409         final char[] chars2 = { 'a' };
410         final char[] chars3 = { 'a', 'b' };
411         final char[] emptyChars = {};
412         assertFalse(StringUtils.containsOnly(null, (char[]) null));
413         assertFalse(StringUtils.containsOnly("", (char[]) null));
414         assertFalse(StringUtils.containsOnly(null, emptyChars));
415         assertFalse(StringUtils.containsOnly(str1, emptyChars));
416         assertTrue(StringUtils.containsOnly("", emptyChars));
417         assertTrue(StringUtils.containsOnly("", chars1));
418         assertFalse(StringUtils.containsOnly(str1, chars1));
419         assertTrue(StringUtils.containsOnly(str1, chars2));
420         assertTrue(StringUtils.containsOnly(str1, chars3));
421         assertTrue(StringUtils.containsOnly(str2, chars1));
422         assertFalse(StringUtils.containsOnly(str2, chars2));
423         assertTrue(StringUtils.containsOnly(str2, chars3));
424         assertFalse(StringUtils.containsOnly(str3, chars1));
425         assertFalse(StringUtils.containsOnly(str3, chars2));
426         assertTrue(StringUtils.containsOnly(str3, chars3));
427     }
428 
429     @Test
430     public void testContainsOnly_String() {
431         final String str1 = "a";
432         final String str2 = "b";
433         final String str3 = "ab";
434         final String chars1 = "b";
435         final String chars2 = "a";
436         final String chars3 = "ab";
437         assertFalse(StringUtils.containsOnly(null, (String) null));
438         assertFalse(StringUtils.containsOnly("", (String) null));
439         assertFalse(StringUtils.containsOnly(null, ""));
440         assertFalse(StringUtils.containsOnly(str1, ""));
441         assertTrue(StringUtils.containsOnly("", ""));
442         assertTrue(StringUtils.containsOnly("", chars1));
443         assertFalse(StringUtils.containsOnly(str1, chars1));
444         assertTrue(StringUtils.containsOnly(str1, chars2));
445         assertTrue(StringUtils.containsOnly(str1, chars3));
446         assertTrue(StringUtils.containsOnly(str2, chars1));
447         assertFalse(StringUtils.containsOnly(str2, chars2));
448         assertTrue(StringUtils.containsOnly(str2, chars3));
449         assertFalse(StringUtils.containsOnly(str3, chars1));
450         assertFalse(StringUtils.containsOnly(str3, chars2));
451         assertTrue(StringUtils.containsOnly(str3, chars3));
452     }
453 
454     @Test
455     public void testContainsWhitespace() {
456         assertFalse(StringUtils.containsWhitespace(""));
457         assertTrue(StringUtils.containsWhitespace(" "));
458         assertFalse(StringUtils.containsWhitespace("a"));
459         assertTrue(StringUtils.containsWhitespace("a "));
460         assertTrue(StringUtils.containsWhitespace(" a"));
461         assertTrue(StringUtils.containsWhitespace("a\t"));
462         assertTrue(StringUtils.containsWhitespace("\n"));
463     }
464 }