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