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 org.apache.commons.lang3.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" },
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
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
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
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
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
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
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
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
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
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
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 }