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.hamcrest.MatcherAssert.assertThat;
22  import static org.junit.jupiter.api.Assertions.assertEquals;
23  import static org.junit.jupiter.api.Assertions.assertFalse;
24  import static org.junit.jupiter.api.Assertions.assertTrue;
25  
26  import java.nio.CharBuffer;
27  import java.util.Locale;
28  
29  import org.hamcrest.core.IsNot;
30  import org.junit.jupiter.api.Test;
31  
32  /**
33   * Unit tests {@link org.apache.commons.lang3.StringUtils} - Equals/IndexOf methods
34   */
35  public class StringUtilsEqualsIndexOfTest extends AbstractLangTest {
36  
37      // The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence)
38      // with a CharSequence implementation whose equals(Object) override requires that the
39      // other object be an instance of CustomCharSequence, even though, as char sequences,
40      // `seq` may equal the other object.
41      private static final class CustomCharSequence implements CharSequence {
42          private final CharSequence seq;
43  
44          CustomCharSequence(final CharSequence seq) {
45              this.seq = seq;
46          }
47  
48          @Override
49          public char charAt(final int index) {
50              return seq.charAt(index);
51          }
52  
53          @Override
54          public boolean equals(final Object obj) {
55              if (!(obj instanceof CustomCharSequence)) {
56                  return false;
57              }
58              final CustomCharSequence other = (CustomCharSequence) obj;
59              return seq.equals(other.seq);
60          }
61  
62          @Override
63          public int hashCode() {
64              return seq.hashCode();
65          }
66  
67          @Override
68          public int length() {
69              return seq.length();
70          }
71  
72          @Override
73          public CharSequence subSequence(final int start, final int end) {
74              return new CustomCharSequence(seq.subSequence(start, end));
75          }
76  
77          @Override
78          public String toString() {
79              return seq.toString();
80          }
81      }
82  
83      private static final String BAR = "bar";
84  
85      private static final String FOO = "foo";
86  
87      private static final String FOOBAR = "foobar";
88  
89      private static final String[] FOOBAR_SUB_ARRAY = {"ob", "ba"};
90  
91      @Test
92      public void testCompare_StringString() {
93          assertEquals(0, StringUtils.compare(null, null));
94          assertTrue(StringUtils.compare(null, "a") < 0);
95          assertTrue(StringUtils.compare("a", null) > 0);
96          assertEquals(0, StringUtils.compare("abc", "abc"));
97          assertTrue(StringUtils.compare("a", "b") < 0);
98          assertTrue(StringUtils.compare("b", "a") > 0);
99          assertTrue(StringUtils.compare("a", "B") > 0);
100         assertTrue(StringUtils.compare("abc", "abd") < 0);
101         assertTrue(StringUtils.compare("ab", "abc") < 0);
102         assertTrue(StringUtils.compare("ab", "ab ") < 0);
103         assertTrue(StringUtils.compare("abc", "ab ") > 0);
104     }
105 
106     @Test
107     public void testCompare_StringStringBoolean() {
108         assertEquals(0, StringUtils.compare(null, null, false));
109         assertTrue(StringUtils.compare(null, "a", true) < 0);
110         assertTrue(StringUtils.compare(null, "a", false) > 0);
111         assertTrue(StringUtils.compare("a", null, true) > 0);
112         assertTrue(StringUtils.compare("a", null, false) < 0);
113         assertEquals(0, StringUtils.compare("abc", "abc", false));
114         assertTrue(StringUtils.compare("a", "b", false) < 0);
115         assertTrue(StringUtils.compare("b", "a", false) > 0);
116         assertTrue(StringUtils.compare("a", "B", false) > 0);
117         assertTrue(StringUtils.compare("abc", "abd", false) < 0);
118         assertTrue(StringUtils.compare("ab", "abc", false) < 0);
119         assertTrue(StringUtils.compare("ab", "ab ", false) < 0);
120         assertTrue(StringUtils.compare("abc", "ab ", false) > 0);
121     }
122 
123     @Test
124     public void testCompareIgnoreCase_StringString() {
125         assertEquals(0, StringUtils.compareIgnoreCase(null, null));
126         assertTrue(StringUtils.compareIgnoreCase(null, "a") < 0);
127         assertTrue(StringUtils.compareIgnoreCase("a", null) > 0);
128         assertEquals(0, StringUtils.compareIgnoreCase("abc", "abc"));
129         assertEquals(0, StringUtils.compareIgnoreCase("abc", "ABC"));
130         assertTrue(StringUtils.compareIgnoreCase("a", "b") < 0);
131         assertTrue(StringUtils.compareIgnoreCase("b", "a") > 0);
132         assertTrue(StringUtils.compareIgnoreCase("a", "B") < 0);
133         assertTrue(StringUtils.compareIgnoreCase("A", "b") < 0);
134         assertTrue(StringUtils.compareIgnoreCase("abc", "ABD") < 0);
135         assertTrue(StringUtils.compareIgnoreCase("ab", "ABC") < 0);
136         assertTrue(StringUtils.compareIgnoreCase("ab", "AB ") < 0);
137         assertTrue(StringUtils.compareIgnoreCase("abc", "AB ") > 0);
138     }
139 
140     @Test
141     public void testCompareIgnoreCase_StringStringBoolean() {
142         assertEquals(0, StringUtils.compareIgnoreCase(null, null, false));
143         assertTrue(StringUtils.compareIgnoreCase(null, "a", true) < 0);
144         assertTrue(StringUtils.compareIgnoreCase(null, "a", false) > 0);
145         assertTrue(StringUtils.compareIgnoreCase("a", null, true) > 0);
146         assertTrue(StringUtils.compareIgnoreCase("a", null, false) < 0);
147         assertEquals(0, StringUtils.compareIgnoreCase("abc", "abc", false));
148         assertEquals(0, StringUtils.compareIgnoreCase("abc", "ABC", false));
149         assertTrue(StringUtils.compareIgnoreCase("a", "b", false) < 0);
150         assertTrue(StringUtils.compareIgnoreCase("b", "a", false) > 0);
151         assertTrue(StringUtils.compareIgnoreCase("a", "B", false) < 0);
152         assertTrue(StringUtils.compareIgnoreCase("A", "b", false) < 0);
153         assertTrue(StringUtils.compareIgnoreCase("abc", "ABD", false) < 0);
154         assertTrue(StringUtils.compareIgnoreCase("ab", "ABC", false) < 0);
155         assertTrue(StringUtils.compareIgnoreCase("ab", "AB ", false) < 0);
156         assertTrue(StringUtils.compareIgnoreCase("abc", "AB ", false) > 0);
157     }
158 
159     @Test
160     public void testCustomCharSequence() {
161         assertThat(new CustomCharSequence(FOO), IsNot.<CharSequence>not(FOO));
162         assertThat(FOO, IsNot.<CharSequence>not(new CustomCharSequence(FOO)));
163         assertEquals(new CustomCharSequence(FOO), new CustomCharSequence(FOO));
164     }
165 
166     @Test
167     public void testEquals() {
168         final CharSequence fooCs = new StringBuilder(FOO), barCs = new StringBuilder(BAR), foobarCs = new StringBuilder(FOOBAR);
169         assertTrue(StringUtils.equals(null, null));
170         assertTrue(StringUtils.equals(fooCs, fooCs));
171         assertTrue(StringUtils.equals(fooCs, new StringBuilder(FOO)));
172         assertTrue(StringUtils.equals(fooCs, new String(new char[] { 'f', 'o', 'o' })));
173         assertTrue(StringUtils.equals(fooCs, new CustomCharSequence(FOO)));
174         assertTrue(StringUtils.equals(new CustomCharSequence(FOO), fooCs));
175         assertFalse(StringUtils.equals(fooCs, new String(new char[] { 'f', 'O', 'O' })));
176         assertFalse(StringUtils.equals(fooCs, barCs));
177         assertFalse(StringUtils.equals(fooCs, null));
178         assertFalse(StringUtils.equals(null, fooCs));
179         assertFalse(StringUtils.equals(fooCs, foobarCs));
180         assertFalse(StringUtils.equals(foobarCs, fooCs));
181     }
182 
183     @Test
184     public void testEqualsAny() {
185         assertFalse(StringUtils.equalsAny(FOO));
186         assertFalse(StringUtils.equalsAny(FOO, new String[]{}));
187 
188         assertTrue(StringUtils.equalsAny(FOO, FOO));
189         assertTrue(StringUtils.equalsAny(FOO, BAR, new String(new char[] { 'f', 'o', 'o' })));
190         assertFalse(StringUtils.equalsAny(FOO, BAR, new String(new char[] { 'f', 'O', 'O' })));
191         assertFalse(StringUtils.equalsAny(FOO, BAR));
192         assertFalse(StringUtils.equalsAny(FOO, BAR, null));
193         assertFalse(StringUtils.equalsAny(null, FOO));
194         assertFalse(StringUtils.equalsAny(FOO, FOOBAR));
195         assertFalse(StringUtils.equalsAny(FOOBAR, FOO));
196 
197         assertTrue(StringUtils.equalsAny(null, null, null));
198         assertFalse(StringUtils.equalsAny(null, FOO, BAR, FOOBAR));
199         assertFalse(StringUtils.equalsAny(FOO, null, BAR));
200         assertTrue(StringUtils.equalsAny(FOO, BAR, null, "", FOO, BAR));
201         assertFalse(StringUtils.equalsAny(FOO, FOO.toUpperCase(Locale.ROOT)));
202 
203         assertFalse(StringUtils.equalsAny(null, (CharSequence[]) null));
204         assertTrue(StringUtils.equalsAny(FOO, new CustomCharSequence("foo")));
205         assertTrue(StringUtils.equalsAny(FOO, new StringBuilder("foo")));
206         assertFalse(StringUtils.equalsAny(FOO, new CustomCharSequence("fOo")));
207         assertFalse(StringUtils.equalsAny(FOO, new StringBuilder("fOo")));
208     }
209 
210     @Test
211     public void testEqualsAnyIgnoreCase() {
212         assertFalse(StringUtils.equalsAnyIgnoreCase(FOO));
213         assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, new String[]{}));
214 
215         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO));
216         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO.toUpperCase(Locale.ROOT)));
217         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO, new String(new char[]{'f', 'o', 'o'})));
218         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, BAR, new String(new char[]{'f', 'O', 'O'})));
219         assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, BAR));
220         assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, BAR, null));
221         assertFalse(StringUtils.equalsAnyIgnoreCase(null, FOO));
222         assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, FOOBAR));
223         assertFalse(StringUtils.equalsAnyIgnoreCase(FOOBAR, FOO));
224 
225         assertTrue(StringUtils.equalsAnyIgnoreCase(null, null, null));
226         assertFalse(StringUtils.equalsAnyIgnoreCase(null, FOO, BAR, FOOBAR));
227         assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, null, BAR));
228         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, BAR, null, "", FOO.toUpperCase(Locale.ROOT), BAR));
229         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO.toUpperCase(Locale.ROOT)));
230 
231         assertFalse(StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null));
232         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new CustomCharSequence("fOo")));
233         assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new StringBuilder("fOo")));
234     }
235 
236     @Test
237     public void testEqualsIgnoreCase() {
238         assertTrue(StringUtils.equalsIgnoreCase(null, null));
239         assertTrue(StringUtils.equalsIgnoreCase(FOO, FOO));
240         assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'o', 'o' })));
241         assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'O', 'O' })));
242         assertFalse(StringUtils.equalsIgnoreCase(FOO, BAR));
243         assertFalse(StringUtils.equalsIgnoreCase(FOO, null));
244         assertFalse(StringUtils.equalsIgnoreCase(null, FOO));
245         assertTrue(StringUtils.equalsIgnoreCase("", ""));
246         assertFalse(StringUtils.equalsIgnoreCase("abcd", "abcd "));
247     }
248 
249     @Test
250     public void testEqualsOnStrings() {
251         assertTrue(StringUtils.equals(null, null));
252         assertTrue(StringUtils.equals(FOO, FOO));
253         assertTrue(StringUtils.equals(FOO, new String(new char[] { 'f', 'o', 'o' })));
254         assertFalse(StringUtils.equals(FOO, new String(new char[] { 'f', 'O', 'O' })));
255         assertFalse(StringUtils.equals(FOO, BAR));
256         assertFalse(StringUtils.equals(FOO, null));
257         assertFalse(StringUtils.equals(null, FOO));
258         assertFalse(StringUtils.equals(FOO, FOOBAR));
259         assertFalse(StringUtils.equals(FOOBAR, FOO));
260     }
261 
262     @Test
263     public void testIndexOf_char() {
264         assertEquals(-1, StringUtils.indexOf(null, ' '));
265         assertEquals(-1, StringUtils.indexOf("", ' '));
266         assertEquals(0, StringUtils.indexOf("aabaabaa", 'a'));
267         assertEquals(2, StringUtils.indexOf("aabaabaa", 'b'));
268 
269         assertEquals(2, StringUtils.indexOf(new StringBuilder("aabaabaa"), 'b'));
270         assertEquals(StringUtils.INDEX_NOT_FOUND, StringUtils.indexOf(new StringBuilder("aabaabaa"), -1738));
271     }
272 
273     @Test
274     public void testIndexOf_charInt() {
275         assertEquals(-1, StringUtils.indexOf(null, ' ', 0));
276         assertEquals(-1, StringUtils.indexOf(null, ' ', -1));
277         assertEquals(-1, StringUtils.indexOf("", ' ', 0));
278         assertEquals(-1, StringUtils.indexOf("", ' ', -1));
279         assertEquals(0, StringUtils.indexOf("aabaabaa", 'a', 0));
280         assertEquals(2, StringUtils.indexOf("aabaabaa", 'b', 0));
281         assertEquals(5, StringUtils.indexOf("aabaabaa", 'b', 3));
282         assertEquals(-1, StringUtils.indexOf("aabaabaa", 'b', 9));
283         assertEquals(2, StringUtils.indexOf("aabaabaa", 'b', -1));
284 
285         assertEquals(5, StringUtils.indexOf(new StringBuilder("aabaabaa"), 'b', 3));
286 
287         //LANG-1300 tests go here
288         final int CODE_POINT = 0x2070E;
289         StringBuilder builder = new StringBuilder();
290         builder.appendCodePoint(CODE_POINT);
291         assertEquals(0, StringUtils.indexOf(builder, CODE_POINT, 0));
292         assertEquals(0, StringUtils.indexOf(builder.toString(), CODE_POINT, 0));
293         builder.appendCodePoint(CODE_POINT);
294         assertEquals(2, StringUtils.indexOf(builder, CODE_POINT, 1));
295         assertEquals(2, StringUtils.indexOf(builder.toString(), CODE_POINT, 1));
296         // inner branch on the supplementary character block
297         final char[] tmp = { (char) 55361 };
298         builder = new StringBuilder();
299         builder.append(tmp);
300         assertEquals(-1, StringUtils.indexOf(builder, CODE_POINT, 0));
301         assertEquals(-1, StringUtils.indexOf(builder.toString(), CODE_POINT, 0));
302         builder.appendCodePoint(CODE_POINT);
303         assertEquals(1, StringUtils.indexOf(builder, CODE_POINT, 0));
304         assertEquals(1, StringUtils.indexOf(builder.toString(), CODE_POINT, 0));
305         assertEquals(-1, StringUtils.indexOf(builder, CODE_POINT, 2));
306         assertEquals(-1, StringUtils.indexOf(builder.toString(), CODE_POINT, 2));
307     }
308 
309     @Test
310     public void testIndexOf_String() {
311         assertEquals(-1, StringUtils.indexOf(null, null));
312         assertEquals(-1, StringUtils.indexOf("", null));
313         assertEquals(0, StringUtils.indexOf("", ""));
314         assertEquals(0, StringUtils.indexOf("aabaabaa", "a"));
315         assertEquals(2, StringUtils.indexOf("aabaabaa", "b"));
316         assertEquals(1, StringUtils.indexOf("aabaabaa", "ab"));
317         assertEquals(0, StringUtils.indexOf("aabaabaa", ""));
318 
319         assertEquals(2, StringUtils.indexOf(new StringBuilder("aabaabaa"), "b"));
320     }
321 
322     @Test
323     public void testIndexOf_StringInt() {
324         assertEquals(-1, StringUtils.indexOf(null, null, 0));
325         assertEquals(-1, StringUtils.indexOf(null, null, -1));
326         assertEquals(-1, StringUtils.indexOf(null, "", 0));
327         assertEquals(-1, StringUtils.indexOf(null, "", -1));
328         assertEquals(-1, StringUtils.indexOf("", null, 0));
329         assertEquals(-1, StringUtils.indexOf("", null, -1));
330         assertEquals(0, StringUtils.indexOf("", "", 0));
331         assertEquals(0, StringUtils.indexOf("", "", -1));
332         assertEquals(0, StringUtils.indexOf("", "", 9));
333         assertEquals(0, StringUtils.indexOf("abc", "", 0));
334         assertEquals(0, StringUtils.indexOf("abc", "", -1));
335         assertEquals(3, StringUtils.indexOf("abc", "", 9));
336         assertEquals(3, StringUtils.indexOf("abc", "", 3));
337         assertEquals(0, StringUtils.indexOf("aabaabaa", "a", 0));
338         assertEquals(2, StringUtils.indexOf("aabaabaa", "b", 0));
339         assertEquals(1, StringUtils.indexOf("aabaabaa", "ab", 0));
340         assertEquals(5, StringUtils.indexOf("aabaabaa", "b", 3));
341         assertEquals(-1, StringUtils.indexOf("aabaabaa", "b", 9));
342         assertEquals(2, StringUtils.indexOf("aabaabaa", "b", -1));
343         assertEquals(2, StringUtils.indexOf("aabaabaa", "", 2));
344 
345         // Test that startIndex works correctly, i.e. cannot match before startIndex
346         assertEquals(7, StringUtils.indexOf("12345678", "8", 5));
347         assertEquals(7, StringUtils.indexOf("12345678", "8", 6));
348         assertEquals(7, StringUtils.indexOf("12345678", "8", 7)); // 7 is last index
349         assertEquals(-1, StringUtils.indexOf("12345678", "8", 8));
350 
351         assertEquals(5, StringUtils.indexOf(new StringBuilder("aabaabaa"), "b", 3));
352     }
353 
354     @Test
355     public void testIndexOfAny_StringCharArray() {
356         assertEquals(-1, StringUtils.indexOfAny(null, (char[]) null));
357         assertEquals(-1, StringUtils.indexOfAny(null, new char[0]));
358         assertEquals(-1, StringUtils.indexOfAny(null, 'a', 'b'));
359 
360         assertEquals(-1, StringUtils.indexOfAny("", (char[]) null));
361         assertEquals(-1, StringUtils.indexOfAny("", new char[0]));
362         assertEquals(-1, StringUtils.indexOfAny("", 'a', 'b'));
363 
364         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", (char[]) null));
365         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", new char[0]));
366         assertEquals(0, StringUtils.indexOfAny("zzabyycdxx", 'z', 'a'));
367         assertEquals(3, StringUtils.indexOfAny("zzabyycdxx", 'b', 'y'));
368         assertEquals(-1, StringUtils.indexOfAny("ab", 'z'));
369     }
370 
371     /**
372      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
373      */
374     @Test
375     public void testIndexOfAny_StringCharArrayWithSupplementaryChars() {
376         assertEquals(0, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20000.toCharArray()));
377         assertEquals(2, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20001.toCharArray()));
378         assertEquals(0, StringUtils.indexOfAny(CharU20000, CharU20000.toCharArray()));
379         assertEquals(-1, StringUtils.indexOfAny(CharU20000, CharU20001.toCharArray()));
380     }
381 
382     @Test
383     public void testIndexOfAny_StringString() {
384         assertEquals(-1, StringUtils.indexOfAny(null, (String) null));
385         assertEquals(-1, StringUtils.indexOfAny(null, ""));
386         assertEquals(-1, StringUtils.indexOfAny(null, "ab"));
387 
388         assertEquals(-1, StringUtils.indexOfAny("", (String) null));
389         assertEquals(-1, StringUtils.indexOfAny("", ""));
390         assertEquals(-1, StringUtils.indexOfAny("", "ab"));
391 
392         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", (String) null));
393         assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", ""));
394         assertEquals(0, StringUtils.indexOfAny("zzabyycdxx", "za"));
395         assertEquals(3, StringUtils.indexOfAny("zzabyycdxx", "by"));
396         assertEquals(-1, StringUtils.indexOfAny("ab", "z"));
397     }
398 
399     @Test
400     public void testIndexOfAny_StringStringArray() {
401         assertEquals(-1, StringUtils.indexOfAny(null, (String[]) null));
402         assertEquals(-1, StringUtils.indexOfAny(null, FOOBAR_SUB_ARRAY));
403         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, (String[]) null));
404         assertEquals(2, StringUtils.indexOfAny(FOOBAR, FOOBAR_SUB_ARRAY));
405         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[0]));
406         assertEquals(-1, StringUtils.indexOfAny(null, new String[0]));
407         assertEquals(-1, StringUtils.indexOfAny("", new String[0]));
408         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[] {"llll"}));
409         assertEquals(0, StringUtils.indexOfAny(FOOBAR, new String[] {""}));
410         assertEquals(0, StringUtils.indexOfAny("", new String[] {""}));
411         assertEquals(-1, StringUtils.indexOfAny("", new String[] {"a"}));
412         assertEquals(-1, StringUtils.indexOfAny("", new String[] {null}));
413         assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[] {null}));
414         assertEquals(-1, StringUtils.indexOfAny(null, new String[] {null}));
415     }
416 
417     /**
418      * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html
419      */
420     @Test
421     public void testIndexOfAny_StringStringWithSupplementaryChars() {
422         assertEquals(0, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20000));
423         assertEquals(2, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20001));
424         assertEquals(0, StringUtils.indexOfAny(CharU20000, CharU20000));
425         assertEquals(-1, StringUtils.indexOfAny(CharU20000, CharU20001));
426     }
427 
428     @Test
429     public void testIndexOfAnyBut_StringCharArray() {
430         assertEquals(-1, StringUtils.indexOfAnyBut(null, (char[]) null));
431         assertEquals(-1, StringUtils.indexOfAnyBut(null));
432         assertEquals(-1, StringUtils.indexOfAnyBut(null, 'a', 'b'));
433 
434         assertEquals(-1, StringUtils.indexOfAnyBut("", (char[]) null));
435         assertEquals(-1, StringUtils.indexOfAnyBut(""));
436         assertEquals(-1, StringUtils.indexOfAnyBut("", 'a', 'b'));
437 
438         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", (char[]) null));
439         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx"));
440         assertEquals(3, StringUtils.indexOfAnyBut("zzabyycdxx", 'z', 'a'));
441         assertEquals(0, StringUtils.indexOfAnyBut("zzabyycdxx", 'b', 'y'));
442         assertEquals(-1, StringUtils.indexOfAnyBut("aba", 'a', 'b'));
443         assertEquals(0, StringUtils.indexOfAnyBut("aba", 'z'));
444     }
445 
446     @Test
447     public void testIndexOfAnyBut_StringCharArrayWithSupplementaryChars() {
448         assertEquals(2, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20000.toCharArray()));
449         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20001.toCharArray()));
450         assertEquals(-1, StringUtils.indexOfAnyBut(CharU20000, CharU20000.toCharArray()));
451         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000, CharU20001.toCharArray()));
452     }
453 
454     @Test
455     public void testIndexOfAnyBut_StringString() {
456         assertEquals(-1, StringUtils.indexOfAnyBut(null, (String) null));
457         assertEquals(-1, StringUtils.indexOfAnyBut(null, ""));
458         assertEquals(-1, StringUtils.indexOfAnyBut(null, "ab"));
459 
460         assertEquals(-1, StringUtils.indexOfAnyBut("", (String) null));
461         assertEquals(-1, StringUtils.indexOfAnyBut("", ""));
462         assertEquals(-1, StringUtils.indexOfAnyBut("", "ab"));
463 
464         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", (String) null));
465         assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", ""));
466         assertEquals(3, StringUtils.indexOfAnyBut("zzabyycdxx", "za"));
467         assertEquals(0, StringUtils.indexOfAnyBut("zzabyycdxx", "by"));
468         assertEquals(0, StringUtils.indexOfAnyBut("ab", "z"));
469     }
470 
471     @Test
472     public void testIndexOfAnyBut_StringStringWithSupplementaryChars() {
473         assertEquals(2, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20000));
474         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20001));
475         assertEquals(-1, StringUtils.indexOfAnyBut(CharU20000, CharU20000));
476         assertEquals(0, StringUtils.indexOfAnyBut(CharU20000, CharU20001));
477     }
478 
479     @Test
480     public void testIndexOfIgnoreCase_String() {
481         assertEquals(-1, StringUtils.indexOfIgnoreCase(null, null));
482         assertEquals(-1, StringUtils.indexOfIgnoreCase(null, ""));
483         assertEquals(-1, StringUtils.indexOfIgnoreCase("", null));
484         assertEquals(0, StringUtils.indexOfIgnoreCase("", ""));
485         assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "a"));
486         assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "A"));
487         assertEquals(2, StringUtils.indexOfIgnoreCase("aabaabaa", "b"));
488         assertEquals(2, StringUtils.indexOfIgnoreCase("aabaabaa", "B"));
489         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "ab"));
490         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB"));
491         assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", ""));
492     }
493 
494     @Test
495     public void testIndexOfIgnoreCase_StringInt() {
496         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", -1));
497         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0));
498         assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 1));
499         assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 2));
500         assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 3));
501         assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 4));
502         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 5));
503         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 6));
504         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 7));
505         assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 8));
506         assertEquals(1, StringUtils.indexOfIgnoreCase("aab", "AB", 1));
507         assertEquals(5, StringUtils.indexOfIgnoreCase("aabaabaa", "", 5));
508         assertEquals(-1, StringUtils.indexOfIgnoreCase("ab", "AAB", 0));
509         assertEquals(-1, StringUtils.indexOfIgnoreCase("aab", "AAB", 1));
510         assertEquals(-1, StringUtils.indexOfIgnoreCase("abc", "", 9));
511     }
512 
513     @Test
514     public void testLANG1193() {
515         assertEquals(0, StringUtils.ordinalIndexOf("abc", "ab", 1));
516     }
517 
518     @Test
519     // Non-overlapping test
520     public void testLANG1241_1() {
521         //                                          0  3  6
522         assertEquals(0, StringUtils.ordinalIndexOf("abaabaab", "ab", 1));
523         assertEquals(3, StringUtils.ordinalIndexOf("abaabaab", "ab", 2));
524         assertEquals(6, StringUtils.ordinalIndexOf("abaabaab", "ab", 3));
525     }
526 
527     @Test
528     // Overlapping matching test
529     public void testLANG1241_2() {
530         //                                          0 2 4
531         assertEquals(0, StringUtils.ordinalIndexOf("abababa", "aba", 1));
532         assertEquals(2, StringUtils.ordinalIndexOf("abababa", "aba", 2));
533         assertEquals(4, StringUtils.ordinalIndexOf("abababa", "aba", 3));
534         assertEquals(0, StringUtils.ordinalIndexOf("abababab", "abab", 1));
535         assertEquals(2, StringUtils.ordinalIndexOf("abababab", "abab", 2));
536         assertEquals(4, StringUtils.ordinalIndexOf("abababab", "abab", 3));
537     }
538 
539     @Test
540     public void testLastIndexOf_char() {
541         assertEquals(-1, StringUtils.lastIndexOf(null, ' '));
542         assertEquals(-1, StringUtils.lastIndexOf("", ' '));
543         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a'));
544         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b'));
545 
546         assertEquals(5, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b'));
547     }
548 
549     @Test
550     public void testLastIndexOf_charInt() {
551         assertEquals(-1, StringUtils.lastIndexOf(null, ' ', 0));
552         assertEquals(-1, StringUtils.lastIndexOf(null, ' ', -1));
553         assertEquals(-1, StringUtils.lastIndexOf("", ' ', 0));
554         assertEquals(-1, StringUtils.lastIndexOf("", ' ', -1));
555         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a', 8));
556         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 8));
557         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", 'b', 3));
558         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 9));
559         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", 'b', -1));
560         assertEquals(0, StringUtils.lastIndexOf("aabaabaa", 'a', 0));
561 
562         assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b', 2));
563 
564         //LANG-1300 addition test
565         final int CODE_POINT = 0x2070E;
566         StringBuilder builder = new StringBuilder();
567         builder.appendCodePoint(CODE_POINT);
568         assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 0));
569         builder.appendCodePoint(CODE_POINT);
570         assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 0));
571         assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 1));
572         assertEquals(2, StringUtils.lastIndexOf(builder, CODE_POINT, 2));
573 
574         builder.append("aaaaa");
575         assertEquals(2, StringUtils.lastIndexOf(builder, CODE_POINT, 4));
576         // inner branch on the supplementary character block
577         final char[] tmp = { (char) 55361 };
578         builder = new StringBuilder();
579         builder.append(tmp);
580         assertEquals(-1, StringUtils.lastIndexOf(builder, CODE_POINT, 0));
581         builder.appendCodePoint(CODE_POINT);
582         assertEquals(-1, StringUtils.lastIndexOf(builder, CODE_POINT, 0));
583         assertEquals(1, StringUtils.lastIndexOf(builder, CODE_POINT, 1 ));
584         assertEquals(-1, StringUtils.lastIndexOf(builder.toString(), CODE_POINT, 0));
585         assertEquals(1, StringUtils.lastIndexOf(builder.toString(), CODE_POINT, 1));
586         assertEquals(StringUtils.INDEX_NOT_FOUND, StringUtils.lastIndexOf(CharBuffer.wrap("[%{.c.0rro"), -1738, 982));
587     }
588 
589     @Test
590     public void testLastIndexOf_String() {
591         assertEquals(-1, StringUtils.lastIndexOf(null, null));
592         assertEquals(-1, StringUtils.lastIndexOf("", null));
593         assertEquals(-1, StringUtils.lastIndexOf("", "a"));
594         assertEquals(0, StringUtils.lastIndexOf("", ""));
595         assertEquals(8, StringUtils.lastIndexOf("aabaabaa", ""));
596         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a"));
597         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b"));
598         assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab"));
599 
600         assertEquals(4, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "ab"));
601     }
602 
603     @Test
604     public void testLastIndexOf_StringInt() {
605         assertEquals(-1, StringUtils.lastIndexOf(null, null, 0));
606         assertEquals(-1, StringUtils.lastIndexOf(null, null, -1));
607         assertEquals(-1, StringUtils.lastIndexOf(null, "", 0));
608         assertEquals(-1, StringUtils.lastIndexOf(null, "", -1));
609         assertEquals(-1, StringUtils.lastIndexOf("", null, 0));
610         assertEquals(-1, StringUtils.lastIndexOf("", null, -1));
611         assertEquals(0, StringUtils.lastIndexOf("", "", 0));
612         assertEquals(-1, StringUtils.lastIndexOf("", "", -1));
613         assertEquals(0, StringUtils.lastIndexOf("", "", 9));
614         assertEquals(0, StringUtils.lastIndexOf("abc", "", 0));
615         assertEquals(-1, StringUtils.lastIndexOf("abc", "", -1));
616         assertEquals(3, StringUtils.lastIndexOf("abc", "", 9));
617         assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a", 8));
618         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 8));
619         assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab", 8));
620         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 3));
621         assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 9));
622         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", -1));
623         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 0));
624         assertEquals(0, StringUtils.lastIndexOf("aabaabaa", "a", 0));
625         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "a", -1));
626 
627         // Test that fromIndex works correctly, i.e. cannot match after fromIndex
628         assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 9));
629         assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 8));
630         assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 7)); // 7 is last index
631         assertEquals(-1, StringUtils.lastIndexOf("12345678", "8", 6));
632 
633         assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 1));
634         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 2));
635         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 2));
636         assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 3));
637 
638         assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "b", 3));
639     }
640 
641     @Test
642     public void testLastIndexOfAny_StringStringArray() {
643         assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence) null));   // test both types of ...
644         assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence[]) null)); // ... varargs invocation
645         assertEquals(-1, StringUtils.lastIndexOfAny(null)); // Missing varag
646         assertEquals(-1, StringUtils.lastIndexOfAny(null, FOOBAR_SUB_ARRAY));
647         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence) null));   // test both types of ...
648         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence[]) null)); // ... varargs invocation
649         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR)); // Missing vararg
650         assertEquals(3, StringUtils.lastIndexOfAny(FOOBAR, FOOBAR_SUB_ARRAY));
651         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[0]));
652         assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[0]));
653         assertEquals(-1, StringUtils.lastIndexOfAny("", new String[0]));
654         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {"llll"}));
655         assertEquals(6, StringUtils.lastIndexOfAny(FOOBAR, new String[] {""}));
656         assertEquals(0, StringUtils.lastIndexOfAny("", new String[] {""}));
657         assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {"a"}));
658         assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {null}));
659         assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {null}));
660         assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[] {null}));
661     }
662 
663     @Test
664     public void testLastIndexOfIgnoreCase_String() {
665         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null));
666         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null));
667         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, ""));
668         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "a"));
669         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", ""));
670         assertEquals(8, StringUtils.lastIndexOfIgnoreCase("aabaabaa", ""));
671         assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "a"));
672         assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A"));
673         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "b"));
674         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B"));
675         assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "ab"));
676         assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB"));
677         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("ab", "AAB"));
678         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aab", "AAB"));
679     }
680 
681     @Test
682     public void testLastIndexOfIgnoreCase_StringInt() {
683         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, 0));
684         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, -1));
685         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", 0));
686         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", -1));
687         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, 0));
688         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, -1));
689         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 0));
690         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "", -1));
691         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 9));
692         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("abc", "", 0));
693         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("abc", "", -1));
694         assertEquals(3, StringUtils.lastIndexOfIgnoreCase("abc", "", 9));
695         assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8));
696         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8));
697         assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8));
698         assertEquals(2, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 3));
699         assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9));
700         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1));
701         assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0));
702         assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0));
703         assertEquals(1, StringUtils.lastIndexOfIgnoreCase("aab", "AB", 1));
704     }
705 
706     @Test
707     public void testLastOrdinalIndexOf() {
708         assertEquals(-1, StringUtils.lastOrdinalIndexOf(null, "*", 42) );
709         assertEquals(-1, StringUtils.lastOrdinalIndexOf("*", null, 42) );
710         assertEquals(0, StringUtils.lastOrdinalIndexOf("", "", 42) );
711         assertEquals(7, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1) );
712         assertEquals(6, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2) );
713         assertEquals(5, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1) );
714         assertEquals(2, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2) );
715         assertEquals(4, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) );
716         assertEquals(1, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) );
717         assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1) );
718         assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2) );
719     }
720 
721     @Test
722     public void testOrdinalIndexOf() {
723         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MIN_VALUE));
724         assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MIN_VALUE));
725         assertEquals(-1, StringUtils.ordinalIndexOf("", "", Integer.MIN_VALUE));
726         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MIN_VALUE));
727         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MIN_VALUE));
728         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MIN_VALUE));
729         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MIN_VALUE));
730 
731         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, -1));
732         assertEquals(-1, StringUtils.ordinalIndexOf("", null, -1));
733         assertEquals(-1, StringUtils.ordinalIndexOf("", "", -1));
734         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", -1));
735         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", -1));
736         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", -1));
737         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", -1));
738 
739         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 0));
740         assertEquals(-1, StringUtils.ordinalIndexOf("", null, 0));
741         assertEquals(-1, StringUtils.ordinalIndexOf("", "", 0));
742         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", 0));
743         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", 0));
744         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 0));
745         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", 0));
746 
747         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 1));
748         assertEquals(-1, StringUtils.ordinalIndexOf("", null, 1));
749         assertEquals(0, StringUtils.ordinalIndexOf("", "", 1));
750         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "a", 1));
751         assertEquals(2, StringUtils.ordinalIndexOf("aabaabaa", "b", 1));
752         assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 1));
753         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 1));
754 
755         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 2));
756         assertEquals(-1, StringUtils.ordinalIndexOf("", null, 2));
757         assertEquals(0, StringUtils.ordinalIndexOf("", "", 2));
758         assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "a", 2));
759         assertEquals(5, StringUtils.ordinalIndexOf("aabaabaa", "b", 2));
760         assertEquals(4, StringUtils.ordinalIndexOf("aabaabaa", "ab", 2));
761         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 2));
762 
763         assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MAX_VALUE));
764         assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MAX_VALUE));
765         assertEquals(0, StringUtils.ordinalIndexOf("", "", Integer.MAX_VALUE));
766         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MAX_VALUE));
767         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MAX_VALUE));
768         assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MAX_VALUE));
769         assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MAX_VALUE));
770 
771         assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 0));
772         assertEquals(0, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 1));
773         assertEquals(1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 2));
774         assertEquals(2, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 3));
775         assertEquals(3, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 4));
776         assertEquals(4, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 5));
777         assertEquals(5, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 6));
778         assertEquals(6, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 7));
779         assertEquals(7, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 8));
780         assertEquals(8, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 9));
781         assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 10));
782 
783         // match at each possible position
784         assertEquals(0, StringUtils.ordinalIndexOf("aaaaaa", "aa", 1));
785         assertEquals(1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 2));
786         assertEquals(2, StringUtils.ordinalIndexOf("aaaaaa", "aa", 3));
787         assertEquals(3, StringUtils.ordinalIndexOf("aaaaaa", "aa", 4));
788         assertEquals(4, StringUtils.ordinalIndexOf("aaaaaa", "aa", 5));
789         assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 6));
790 
791         assertEquals(0, StringUtils.ordinalIndexOf("ababab", "aba", 1));
792         assertEquals(2, StringUtils.ordinalIndexOf("ababab", "aba", 2));
793         assertEquals(-1, StringUtils.ordinalIndexOf("ababab", "aba", 3));
794 
795         assertEquals(0, StringUtils.ordinalIndexOf("abababab", "abab", 1));
796         assertEquals(2, StringUtils.ordinalIndexOf("abababab", "abab", 2));
797         assertEquals(4, StringUtils.ordinalIndexOf("abababab", "abab", 3));
798         assertEquals(-1, StringUtils.ordinalIndexOf("abababab", "abab", 4));
799     }
800 }