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