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.junit.jupiter.api.Assertions.assertEquals;
20  import static org.junit.jupiter.api.Assertions.assertFalse;
21  import static org.junit.jupiter.api.Assertions.assertNull;
22  import static org.junit.jupiter.api.Assertions.assertSame;
23  import static org.junit.jupiter.api.Assertions.assertTrue;
24  
25  import org.junit.jupiter.api.Test;
26  
27  /**
28   * Tests {@link StringUtils} - Substring methods
29   */
30  class StringUtilsSubstringTest extends AbstractLangTest {
31      private static final String FOO = "foo";
32      private static final String BAR = "bar";
33      private static final String BAZ = "baz";
34      private static final String FOOBAR = "foobar";
35      private static final String SENTENCE = "foo bar baz";
36  
37      @Test
38      void testCountMatches_char() {
39          assertEquals(0, StringUtils.countMatches(null, 'D'));
40          assertEquals(5, StringUtils.countMatches("one long someone sentence of one", ' '));
41          assertEquals(6, StringUtils.countMatches("one long someone sentence of one", 'o'));
42          // NUL char
43          assertEquals(0, StringUtils.countMatches("oooooooooooo", '\0'));
44      }
45  
46      @Test
47      void testCountMatches_String() {
48          assertEquals(0, StringUtils.countMatches(null, null));
49          assertEquals(0, StringUtils.countMatches("blah", null));
50          assertEquals(0, StringUtils.countMatches(null, "DD"));
51  
52          assertEquals(0, StringUtils.countMatches("x", ""));
53          assertEquals(0, StringUtils.countMatches("", ""));
54  
55          assertEquals(3,
56               StringUtils.countMatches("one long someone sentence of one", "one"));
57          assertEquals(0,
58               StringUtils.countMatches("one long someone sentence of one", "two"));
59          assertEquals(4,
60               StringUtils.countMatches("oooooooooooo", "ooo"));
61          assertEquals(0, StringUtils.countMatches(null, "?"));
62          assertEquals(0, StringUtils.countMatches("", "?"));
63          assertEquals(0, StringUtils.countMatches("abba", null));
64          assertEquals(0, StringUtils.countMatches("abba", ""));
65          assertEquals(2, StringUtils.countMatches("abba", "a"));
66          assertEquals(1, StringUtils.countMatches("abba", "ab"));
67          assertEquals(0, StringUtils.countMatches("abba", "xxx"));
68          assertEquals(1, StringUtils.countMatches("ababa", "aba"));
69      }
70  
71      @Test
72      void testLeft_String() {
73          assertSame(null, StringUtils.left(null, -1));
74          assertSame(null, StringUtils.left(null, 0));
75          assertSame(null, StringUtils.left(null, 2));
76  
77          assertEquals("", StringUtils.left("", -1));
78          assertEquals("", StringUtils.left("", 0));
79          assertEquals("", StringUtils.left("", 2));
80  
81          assertEquals("", StringUtils.left(FOOBAR, -1));
82          assertEquals("", StringUtils.left(FOOBAR, 0));
83          assertEquals(FOO, StringUtils.left(FOOBAR, 3));
84          assertSame(FOOBAR, StringUtils.left(FOOBAR, 80));
85      }
86  
87      @Test
88      void testLeftSurrogatePair() {
89          // U+1F600 GRINNING FACE is a supplementary code point stored as a surrogate pair
90          final String grin = "😀";
91          assertEquals("", StringUtils.left(grin, 0));
92          assertEquals("", StringUtils.left(grin, 1));
93          assertEquals(grin, StringUtils.left(grin, 2));
94          assertEquals(grin, StringUtils.left(grin, 3));
95  
96          assertEquals("a", StringUtils.left("a" + grin, 1));
97          assertEquals("a", StringUtils.left("a" + grin, 2));
98          assertEquals("a" + grin, StringUtils.left("a" + grin, 3));
99  
100         final String source = "a" + grin + "b" + grin + "cd" + grin + "ef";
101         for (int len = 0; len <= source.length(); len++) {
102             final String result = StringUtils.left(source, len);
103             assertTrue(result.length() <= len, () -> "result longer than len: " + result);
104             for (int i = 0; i < result.length(); i++) {
105                 final char ch = result.charAt(i);
106                 if (Character.isHighSurrogate(ch)) {
107                     assertTrue(i + 1 < result.length() && Character.isLowSurrogate(result.charAt(i + 1)), "lone high surrogate in: " + result);
108                     i++; // skip the paired low surrogate
109                 } else {
110                     assertFalse(Character.isLowSurrogate(ch), "lone low surrogate in: " + result);
111                 }
112             }
113         }
114     }
115 
116     @Test
117     void testMid_String() {
118         assertSame(null, StringUtils.mid(null, -1, 0));
119         assertSame(null, StringUtils.mid(null, 0, -1));
120         assertSame(null, StringUtils.mid(null, 3, 0));
121         assertSame(null, StringUtils.mid(null, 3, 2));
122 
123         assertEquals("", StringUtils.mid("", 0, -1));
124         assertEquals("", StringUtils.mid("", 0, 0));
125         assertEquals("", StringUtils.mid("", 0, 2));
126 
127         assertEquals("", StringUtils.mid(FOOBAR, 3, -1));
128         assertEquals("", StringUtils.mid(FOOBAR, 3, 0));
129         assertEquals("b", StringUtils.mid(FOOBAR, 3, 1));
130         assertEquals(FOO, StringUtils.mid(FOOBAR, 0, 3));
131         assertEquals(BAR, StringUtils.mid(FOOBAR, 3, 3));
132         assertEquals(FOOBAR, StringUtils.mid(FOOBAR, 0, 80));
133         assertEquals(BAR, StringUtils.mid(FOOBAR, 3, 80));
134         assertEquals("", StringUtils.mid(FOOBAR, 9, 3));
135         assertEquals(FOO, StringUtils.mid(FOOBAR, -1, 3));
136         // LANG: a len that overflows pos + len must still return the rest
137         assertEquals(BAR, StringUtils.mid(FOOBAR, 3, Integer.MAX_VALUE));
138         assertEquals(FOOBAR, StringUtils.mid(FOOBAR, 0, Integer.MAX_VALUE));
139     }
140 
141     @Test
142     void testMidSurrogatePair() {
143         // U+1F600 GRINNING FACE is a supplementary code point stored as a surrogate pair
144         final String grin = "😀";
145         assertEquals("", StringUtils.mid(grin, 0, 0));
146         assertEquals("", StringUtils.mid(grin, 0, 1));
147         assertEquals(grin, StringUtils.mid(grin, 0, 2));
148         assertEquals(grin, StringUtils.mid(grin, 0, 3));
149         assertEquals("", StringUtils.mid(grin, 1, 1));
150         assertEquals("", StringUtils.mid(grin, 1, 2));
151 
152         assertEquals("a", StringUtils.mid("a" + grin + "b", 0, 2));
153         assertEquals(grin, StringUtils.mid("a" + grin + "b", 1, 2));
154         assertEquals("b", StringUtils.mid("a" + grin + "b", 2, 2));
155 
156         final String source = "a" + grin + "b" + grin + "cd" + grin + "ef";
157         for (int pos = 0; pos <= source.length(); pos++) {
158             for (int len = 0; len <= source.length(); len++) {
159                 final String result = StringUtils.mid(source, pos, len);
160                 for (int i = 0; i < result.length(); i++) {
161                     final char ch = result.charAt(i);
162                     if (Character.isHighSurrogate(ch)) {
163                         assertTrue(i + 1 < result.length() && Character.isLowSurrogate(result.charAt(i + 1)), "lone high surrogate in: " + result);
164                         i++; // skip the paired low surrogate
165                     } else {
166                         assertFalse(Character.isLowSurrogate(ch), "lone low surrogate in: " + result);
167                     }
168                 }
169             }
170         }
171     }
172 
173     @Test
174     void testRight_String() {
175         assertSame(null, StringUtils.right(null, -1));
176         assertSame(null, StringUtils.right(null, 0));
177         assertSame(null, StringUtils.right(null, 2));
178 
179         assertEquals("", StringUtils.right("", -1));
180         assertEquals("", StringUtils.right("", 0));
181         assertEquals("", StringUtils.right("", 2));
182 
183         assertEquals("", StringUtils.right(FOOBAR, -1));
184         assertEquals("", StringUtils.right(FOOBAR, 0));
185         assertEquals(BAR, StringUtils.right(FOOBAR, 3));
186         assertSame(FOOBAR, StringUtils.right(FOOBAR, 80));
187     }
188 
189     @Test
190     void testRightSurrogatePair() {
191         // U+1F600 GRINNING FACE is a supplementary code point stored as a surrogate pair
192         final String grin = "😀";
193         assertEquals("", StringUtils.right(grin, 0));
194         assertEquals("", StringUtils.right(grin, 1));
195         assertEquals(grin, StringUtils.right(grin, 2));
196         assertEquals(grin, StringUtils.right(grin, 3));
197 
198         assertEquals("a", StringUtils.right(grin + "a", 1));
199         assertEquals("a", StringUtils.right(grin + "a", 2));
200         assertEquals(grin + "a", StringUtils.right(grin + "a", 3));
201 
202         final String source = "a" + grin + "b" + grin + "cd" + grin + "ef";
203         for (int len = 0; len <= source.length(); len++) {
204             final String result = StringUtils.right(source, len);
205             assertTrue(result.length() <= len, () -> "result longer than len: " + result);
206             for (int i = 0; i < result.length(); i++) {
207                 final char ch = result.charAt(i);
208                 if (Character.isHighSurrogate(ch)) {
209                     assertTrue(i + 1 < result.length() && Character.isLowSurrogate(result.charAt(i + 1)), "lone high surrogate in: " + result);
210                     i++; // skip the paired low surrogate
211                 } else {
212                     assertFalse(Character.isLowSurrogate(ch), "lone low surrogate in: " + result);
213                 }
214             }
215         }
216     }
217 
218     @Test
219     void testSubstring_StringInt() {
220         assertNull(StringUtils.substring(null, 0));
221         assertEquals("", StringUtils.substring("", 0));
222         assertEquals("", StringUtils.substring("", 2));
223 
224         assertEquals("", StringUtils.substring(SENTENCE, 80));
225         assertEquals(BAZ, StringUtils.substring(SENTENCE, 8));
226         assertEquals(BAZ, StringUtils.substring(SENTENCE, -3));
227         assertEquals(SENTENCE, StringUtils.substring(SENTENCE, 0));
228         assertEquals("abc", StringUtils.substring("abc", -4));
229         assertEquals("abc", StringUtils.substring("abc", -3));
230         assertEquals("bc", StringUtils.substring("abc", -2));
231         assertEquals("c", StringUtils.substring("abc", -1));
232         assertEquals("abc", StringUtils.substring("abc", 0));
233         assertEquals("bc", StringUtils.substring("abc", 1));
234         assertEquals("c", StringUtils.substring("abc", 2));
235         assertEquals("", StringUtils.substring("abc", 3));
236         assertEquals("", StringUtils.substring("abc", 4));
237     }
238 
239     @Test
240     void testSubstring_StringIntInt() {
241         assertNull(StringUtils.substring(null, 0, 0));
242         assertNull(StringUtils.substring(null, 1, 2));
243         assertEquals("", StringUtils.substring("", 0, 0));
244         assertEquals("", StringUtils.substring("", 1, 2));
245         assertEquals("", StringUtils.substring("", -2, -1));
246 
247         assertEquals("", StringUtils.substring(SENTENCE, 8, 6));
248         assertEquals(FOO, StringUtils.substring(SENTENCE, 0, 3));
249         assertEquals("o", StringUtils.substring(SENTENCE, -9, 3));
250         assertEquals(FOO, StringUtils.substring(SENTENCE, 0, -8));
251         assertEquals("o", StringUtils.substring(SENTENCE, -9, -8));
252         assertEquals(SENTENCE, StringUtils.substring(SENTENCE, 0, 80));
253         assertEquals("", StringUtils.substring(SENTENCE, 2, 2));
254         assertEquals("b", StringUtils.substring("abc", -2, -1));
255     }
256 
257     @Test
258     void testSubstringAfter_StringInt() {
259         assertNull(StringUtils.substringAfter(null, 0));
260         assertNull(StringUtils.substringAfter(null, 'X'));
261         assertEquals("", StringUtils.substringAfter("", 0));
262         assertEquals("", StringUtils.substringAfter("", 'X'));
263 
264         assertEquals("", StringUtils.substringAfter("foo", 0));
265         assertEquals("ot", StringUtils.substringAfter("foot", 'o'));
266         assertEquals("bc", StringUtils.substringAfter("abc", 'a'));
267         assertEquals("cba", StringUtils.substringAfter("abcba", 'b'));
268         assertEquals("", StringUtils.substringAfter("abc", 'c'));
269         assertEquals("", StringUtils.substringAfter("abc", 'd'));
270 
271         // a supplementary code point occupies two chars
272         final int grin = 0x1F600;
273         final String s = new String(Character.toChars(grin));
274         assertEquals("world", StringUtils.substringAfter("hello" + s + "world", grin));
275         assertEquals("", StringUtils.substringAfter("hello" + s, grin));
276     }
277 
278     @Test
279     void testSubstringAfter_StringString() {
280         assertEquals("barXXbaz", StringUtils.substringAfter("fooXXbarXXbaz", "XX"));
281 
282         assertNull(StringUtils.substringAfter(null, null));
283         assertNull(StringUtils.substringAfter(null, ""));
284         assertNull(StringUtils.substringAfter(null, "XX"));
285         assertEquals("", StringUtils.substringAfter("", null));
286         assertEquals("", StringUtils.substringAfter("", ""));
287         assertEquals("", StringUtils.substringAfter("", "XX"));
288 
289         assertEquals("", StringUtils.substringAfter("foo", null));
290         assertEquals("ot", StringUtils.substringAfter("foot", "o"));
291         assertEquals("bc", StringUtils.substringAfter("abc", "a"));
292         assertEquals("cba", StringUtils.substringAfter("abcba", "b"));
293         assertEquals("", StringUtils.substringAfter("abc", "c"));
294         assertEquals("abc", StringUtils.substringAfter("abc", ""));
295         assertEquals("", StringUtils.substringAfter("abc", "d"));
296     }
297 
298     @Test
299     void testSubstringAfterLast_StringInt() {
300         assertNull(StringUtils.substringAfterLast(null, 0));
301         assertNull(StringUtils.substringAfterLast(null, 'X'));
302         assertEquals("", StringUtils.substringAfterLast("", 0));
303         assertEquals("", StringUtils.substringAfterLast("", 'a'));
304 
305         assertEquals("", StringUtils.substringAfterLast("foo", 0));
306         assertEquals("", StringUtils.substringAfterLast("foo", 'b'));
307         assertEquals("t", StringUtils.substringAfterLast("foot", 'o'));
308         assertEquals("bc", StringUtils.substringAfterLast("abc", 'a'));
309         assertEquals("a", StringUtils.substringAfterLast("abcba", 'b'));
310         assertEquals("", StringUtils.substringAfterLast("abc", 'c'));
311         assertEquals("", StringUtils.substringAfterLast("", 'd'));
312 
313         // a supplementary code point occupies two chars
314         final int grin = 0x1F600;
315         final String s = new String(Character.toChars(grin));
316         assertEquals("", StringUtils.substringAfterLast("hello" + s, grin));
317         assertEquals("x", StringUtils.substringAfterLast(s + "a" + s + "x", grin));
318         assertEquals("world", StringUtils.substringAfterLast("a" + s + "world", grin));
319     }
320 
321     @Test
322     void testSubstringAfterLast_StringString() {
323         assertEquals("baz", StringUtils.substringAfterLast("fooXXbarXXbaz", "XX"));
324 
325         assertNull(StringUtils.substringAfterLast(null, null));
326         assertNull(StringUtils.substringAfterLast(null, ""));
327         assertNull(StringUtils.substringAfterLast(null, "XX"));
328         assertEquals("", StringUtils.substringAfterLast("", null));
329         assertEquals("", StringUtils.substringAfterLast("", ""));
330         assertEquals("", StringUtils.substringAfterLast("", "a"));
331 
332         assertEquals("", StringUtils.substringAfterLast("foo", null));
333         assertEquals("", StringUtils.substringAfterLast("foo", "b"));
334         assertEquals("t", StringUtils.substringAfterLast("foot", "o"));
335         assertEquals("bc", StringUtils.substringAfterLast("abc", "a"));
336         assertEquals("a", StringUtils.substringAfterLast("abcba", "b"));
337         assertEquals("", StringUtils.substringAfterLast("abc", "c"));
338         assertEquals("", StringUtils.substringAfterLast("", "d"));
339         assertEquals("", StringUtils.substringAfterLast("abc", ""));
340     }
341 
342     @Test
343     void testSubstringBefore_StringInt() {
344         assertEquals("foo", StringUtils.substringBefore("fooXXbarXXbaz", 'X'));
345 
346         assertNull(StringUtils.substringBefore(null, 0));
347         assertNull(StringUtils.substringBefore(null, 'X'));
348         assertEquals("", StringUtils.substringBefore("", 0));
349         assertEquals("", StringUtils.substringBefore("", 'X'));
350 
351         assertEquals("foo", StringUtils.substringBefore("foo", 0));
352         assertEquals("foo", StringUtils.substringBefore("foo", 'b'));
353         assertEquals("f", StringUtils.substringBefore("foot", 'o'));
354         assertEquals("", StringUtils.substringBefore("abc", 'a'));
355         assertEquals("a", StringUtils.substringBefore("abcba", 'b'));
356         assertEquals("ab", StringUtils.substringBefore("abc", 'c'));
357         assertEquals("abc", StringUtils.substringBefore("abc", 0));
358     }
359 
360     @Test
361     void testSubstringBefore_StringString() {
362         assertEquals("foo", StringUtils.substringBefore("fooXXbarXXbaz", "XX"));
363 
364         assertNull(StringUtils.substringBefore(null, null));
365         assertNull(StringUtils.substringBefore(null, ""));
366         assertNull(StringUtils.substringBefore(null, "XX"));
367         assertEquals("", StringUtils.substringBefore("", null));
368         assertEquals("", StringUtils.substringBefore("", ""));
369         assertEquals("", StringUtils.substringBefore("", "XX"));
370 
371         assertEquals("foo", StringUtils.substringBefore("foo", null));
372         assertEquals("foo", StringUtils.substringBefore("foo", "b"));
373         assertEquals("f", StringUtils.substringBefore("foot", "o"));
374         assertEquals("", StringUtils.substringBefore("abc", "a"));
375         assertEquals("a", StringUtils.substringBefore("abcba", "b"));
376         assertEquals("ab", StringUtils.substringBefore("abc", "c"));
377         assertEquals("", StringUtils.substringBefore("abc", ""));
378         assertEquals("abc", StringUtils.substringBefore("abc", "X"));
379     }
380 
381     @Test
382     void testSubstringBeforeLast_StringString() {
383         assertEquals("fooXXbar", StringUtils.substringBeforeLast("fooXXbarXXbaz", "XX"));
384 
385         assertNull(StringUtils.substringBeforeLast(null, null));
386         assertNull(StringUtils.substringBeforeLast(null, ""));
387         assertNull(StringUtils.substringBeforeLast(null, "XX"));
388         assertEquals("", StringUtils.substringBeforeLast("", null));
389         assertEquals("", StringUtils.substringBeforeLast("", ""));
390         assertEquals("", StringUtils.substringBeforeLast("", "XX"));
391 
392         assertEquals("foo", StringUtils.substringBeforeLast("foo", null));
393         assertEquals("foo", StringUtils.substringBeforeLast("foo", "b"));
394         assertEquals("fo", StringUtils.substringBeforeLast("foo", "o"));
395         assertEquals("abc\r\n", StringUtils.substringBeforeLast("abc\r\n", "d"));
396         assertEquals("abc", StringUtils.substringBeforeLast("abcdabc", "d"));
397         assertEquals("abcdabc", StringUtils.substringBeforeLast("abcdabcd", "d"));
398         assertEquals("a", StringUtils.substringBeforeLast("abc", "b"));
399         assertEquals("abc ", StringUtils.substringBeforeLast("abc \n", "\n"));
400         assertEquals("a", StringUtils.substringBeforeLast("a", null));
401         assertEquals("a", StringUtils.substringBeforeLast("a", ""));
402         assertEquals("", StringUtils.substringBeforeLast("a", "a"));
403     }
404 
405     @Test
406     void testSubstringBetween_StringString() {
407         assertNull(StringUtils.substringBetween(null, "tag"));
408         assertEquals("", StringUtils.substringBetween("", ""));
409         assertNull(StringUtils.substringBetween("", "abc"));
410         assertEquals("", StringUtils.substringBetween("    ", " "));
411         assertNull(StringUtils.substringBetween("abc", null));
412         assertEquals("", StringUtils.substringBetween("abc", ""));
413         assertNull(StringUtils.substringBetween("abc", "a"));
414         assertEquals("bc", StringUtils.substringBetween("abca", "a"));
415         assertEquals("bc", StringUtils.substringBetween("abcabca", "a"));
416         assertEquals("bar", StringUtils.substringBetween("\nbar\n", "\n"));
417     }
418 
419     @Test
420     void testSubstringBetween_StringStringString() {
421         assertNull(StringUtils.substringBetween(null, "", ""));
422         assertNull(StringUtils.substringBetween("", null, ""));
423         assertNull(StringUtils.substringBetween("", "", null));
424         assertEquals("", StringUtils.substringBetween("", "", ""));
425         assertEquals("", StringUtils.substringBetween("foo", "", ""));
426         assertNull(StringUtils.substringBetween("foo", "", "]"));
427         assertNull(StringUtils.substringBetween("foo", "[", "]"));
428         assertEquals("", StringUtils.substringBetween("    ", " ", "  "));
429         assertEquals("bar", StringUtils.substringBetween("<foo>bar</foo>", "<foo>", "</foo>"));
430         assertEquals("abc", StringUtils.substringBetween("yabczyabcz", "y", "z"));
431     }
432 
433     /**
434          * Tests the substringsBetween method that returns a String Array of substrings.
435          */
436         @Test
437         void testSubstringsBetween_StringStringString() {
438 
439             String[] results = StringUtils.substringsBetween("[one], [two], [three]", "[", "]");
440             assertEquals(3, results.length);
441             assertEquals("one", results[0]);
442             assertEquals("two", results[1]);
443             assertEquals("three", results[2]);
444 
445             results = StringUtils.substringsBetween("[one], [two], three", "[", "]");
446             assertEquals(2, results.length);
447             assertEquals("one", results[0]);
448             assertEquals("two", results[1]);
449 
450             results = StringUtils.substringsBetween("[one], [two], three]", "[", "]");
451             assertEquals(2, results.length);
452             assertEquals("one", results[0]);
453             assertEquals("two", results[1]);
454 
455             results = StringUtils.substringsBetween("[one], two], three]", "[", "]");
456             assertEquals(1, results.length);
457             assertEquals("one", results[0]);
458 
459             results = StringUtils.substringsBetween("one], two], [three]", "[", "]");
460             assertEquals(1, results.length);
461             assertEquals("three", results[0]);
462 
463             // 'ab hello ba' will match, but 'ab non ba' won't
464             // this is because the 'a' is shared between the two and can't be matched twice
465             results = StringUtils.substringsBetween("aabhellobabnonba", "ab", "ba");
466             assertEquals(1, results.length);
467             assertEquals("hello", results[0]);
468 
469             results = StringUtils.substringsBetween("one, two, three", "[", "]");
470             assertNull(results);
471 
472             results = StringUtils.substringsBetween("[one, two, three", "[", "]");
473             assertNull(results);
474 
475             results = StringUtils.substringsBetween("one, two, three]", "[", "]");
476             assertNull(results);
477 
478             results = StringUtils.substringsBetween("[one], [two], [three]", "[", null);
479             assertNull(results);
480 
481             results = StringUtils.substringsBetween("[one], [two], [three]", null, "]");
482             assertNull(results);
483 
484             results = StringUtils.substringsBetween("[one], [two], [three]", "", "");
485             assertNull(results);
486 
487             results = StringUtils.substringsBetween(null, "[", "]");
488             assertNull(results);
489 
490             results = StringUtils.substringsBetween("", "[", "]");
491             assertEquals(0, results.length);
492         }
493 
494 }