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 private static final String BAR = "bar"; 38 39 private static final String FOO = "foo"; 40 41 private static final String FOOBAR = "foobar"; 42 43 private static final String[] FOOBAR_SUB_ARRAY = {"ob", "ba"}; 44 45 // The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence) 46 // with a CharSequence implementation whose equals(Object) override requires that the 47 // other object be an instance of CustomCharSequence, even though, as char sequences, 48 // `seq` may equal the other object. 49 private static class CustomCharSequence implements CharSequence { 50 private final CharSequence seq; 51 CustomCharSequence(final CharSequence seq)52 CustomCharSequence(final CharSequence seq) { 53 this.seq = seq; 54 } 55 56 @Override charAt(final int index)57 public char charAt(final int index) { 58 return seq.charAt(index); 59 } 60 61 @Override length()62 public int length() { 63 return seq.length(); 64 } 65 66 @Override subSequence(final int start, final int end)67 public CharSequence subSequence(final int start, final int end) { 68 return new CustomCharSequence(seq.subSequence(start, end)); 69 } 70 71 @Override equals(final Object obj)72 public boolean equals(final Object obj) { 73 if (!(obj instanceof CustomCharSequence)) { 74 return false; 75 } 76 final CustomCharSequence other = (CustomCharSequence) obj; 77 return seq.equals(other.seq); 78 } 79 80 @Override hashCode()81 public int hashCode() { 82 return seq.hashCode(); 83 } 84 85 @Override toString()86 public String toString() { 87 return seq.toString(); 88 } 89 } 90 91 @Test testCustomCharSequence()92 public void testCustomCharSequence() { 93 assertThat(new CustomCharSequence(FOO), IsNot.<CharSequence>not(FOO)); 94 assertThat(FOO, IsNot.<CharSequence>not(new CustomCharSequence(FOO))); 95 assertEquals(new CustomCharSequence(FOO), new CustomCharSequence(FOO)); 96 } 97 98 @Test testEquals()99 public void testEquals() { 100 final CharSequence fooCs = new StringBuilder(FOO), barCs = new StringBuilder(BAR), foobarCs = new StringBuilder(FOOBAR); 101 assertTrue(StringUtils.equals(null, null)); 102 assertTrue(StringUtils.equals(fooCs, fooCs)); 103 assertTrue(StringUtils.equals(fooCs, new StringBuilder(FOO))); 104 assertTrue(StringUtils.equals(fooCs, new String(new char[] { 'f', 'o', 'o' }))); 105 assertTrue(StringUtils.equals(fooCs, new CustomCharSequence(FOO))); 106 assertTrue(StringUtils.equals(new CustomCharSequence(FOO), fooCs)); 107 assertFalse(StringUtils.equals(fooCs, new String(new char[] { 'f', 'O', 'O' }))); 108 assertFalse(StringUtils.equals(fooCs, barCs)); 109 assertFalse(StringUtils.equals(fooCs, null)); 110 assertFalse(StringUtils.equals(null, fooCs)); 111 assertFalse(StringUtils.equals(fooCs, foobarCs)); 112 assertFalse(StringUtils.equals(foobarCs, fooCs)); 113 } 114 115 @Test testEqualsOnStrings()116 public void testEqualsOnStrings() { 117 assertTrue(StringUtils.equals(null, null)); 118 assertTrue(StringUtils.equals(FOO, FOO)); 119 assertTrue(StringUtils.equals(FOO, new String(new char[] { 'f', 'o', 'o' }))); 120 assertFalse(StringUtils.equals(FOO, new String(new char[] { 'f', 'O', 'O' }))); 121 assertFalse(StringUtils.equals(FOO, BAR)); 122 assertFalse(StringUtils.equals(FOO, null)); 123 assertFalse(StringUtils.equals(null, FOO)); 124 assertFalse(StringUtils.equals(FOO, FOOBAR)); 125 assertFalse(StringUtils.equals(FOOBAR, FOO)); 126 } 127 128 @Test testEqualsIgnoreCase()129 public void testEqualsIgnoreCase() { 130 assertTrue(StringUtils.equalsIgnoreCase(null, null)); 131 assertTrue(StringUtils.equalsIgnoreCase(FOO, FOO)); 132 assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'o', 'o' }))); 133 assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'O', 'O' }))); 134 assertFalse(StringUtils.equalsIgnoreCase(FOO, BAR)); 135 assertFalse(StringUtils.equalsIgnoreCase(FOO, null)); 136 assertFalse(StringUtils.equalsIgnoreCase(null, FOO)); 137 assertTrue(StringUtils.equalsIgnoreCase("", "")); 138 assertFalse(StringUtils.equalsIgnoreCase("abcd", "abcd ")); 139 } 140 141 @Test testEqualsAny()142 public void testEqualsAny() { 143 assertFalse(StringUtils.equalsAny(FOO)); 144 assertFalse(StringUtils.equalsAny(FOO, new String[]{})); 145 146 assertTrue(StringUtils.equalsAny(FOO, FOO)); 147 assertTrue(StringUtils.equalsAny(FOO, BAR, new String(new char[] { 'f', 'o', 'o' }))); 148 assertFalse(StringUtils.equalsAny(FOO, BAR, new String(new char[] { 'f', 'O', 'O' }))); 149 assertFalse(StringUtils.equalsAny(FOO, BAR)); 150 assertFalse(StringUtils.equalsAny(FOO, BAR, null)); 151 assertFalse(StringUtils.equalsAny(null, FOO)); 152 assertFalse(StringUtils.equalsAny(FOO, FOOBAR)); 153 assertFalse(StringUtils.equalsAny(FOOBAR, FOO)); 154 155 assertTrue(StringUtils.equalsAny(null, null, null)); 156 assertFalse(StringUtils.equalsAny(null, FOO, BAR, FOOBAR)); 157 assertFalse(StringUtils.equalsAny(FOO, null, BAR)); 158 assertTrue(StringUtils.equalsAny(FOO, BAR, null, "", FOO, BAR)); 159 assertFalse(StringUtils.equalsAny(FOO, FOO.toUpperCase(Locale.ROOT))); 160 161 assertFalse(StringUtils.equalsAny(null, (CharSequence[]) null)); 162 assertTrue(StringUtils.equalsAny(FOO, new CustomCharSequence("foo"))); 163 assertTrue(StringUtils.equalsAny(FOO, new StringBuilder("foo"))); 164 assertFalse(StringUtils.equalsAny(FOO, new CustomCharSequence("fOo"))); 165 assertFalse(StringUtils.equalsAny(FOO, new StringBuilder("fOo"))); 166 } 167 168 @Test testEqualsAnyIgnoreCase()169 public void testEqualsAnyIgnoreCase() { 170 assertFalse(StringUtils.equalsAnyIgnoreCase(FOO)); 171 assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, new String[]{})); 172 173 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO)); 174 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO.toUpperCase(Locale.ROOT))); 175 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO, new String(new char[]{'f', 'o', 'o'}))); 176 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, BAR, new String(new char[]{'f', 'O', 'O'}))); 177 assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, BAR)); 178 assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, BAR, null)); 179 assertFalse(StringUtils.equalsAnyIgnoreCase(null, FOO)); 180 assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, FOOBAR)); 181 assertFalse(StringUtils.equalsAnyIgnoreCase(FOOBAR, FOO)); 182 183 assertTrue(StringUtils.equalsAnyIgnoreCase(null, null, null)); 184 assertFalse(StringUtils.equalsAnyIgnoreCase(null, FOO, BAR, FOOBAR)); 185 assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, null, BAR)); 186 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, BAR, null, "", FOO.toUpperCase(Locale.ROOT), BAR)); 187 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO.toUpperCase(Locale.ROOT))); 188 189 assertFalse(StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null)); 190 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new CustomCharSequence("fOo"))); 191 assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new StringBuilder("fOo"))); 192 } 193 194 @Test testCompare_StringString()195 public void testCompare_StringString() { 196 assertEquals(0, StringUtils.compare(null, null)); 197 assertTrue(StringUtils.compare(null, "a") < 0); 198 assertTrue(StringUtils.compare("a", null) > 0); 199 assertEquals(0, StringUtils.compare("abc", "abc")); 200 assertTrue(StringUtils.compare("a", "b") < 0); 201 assertTrue(StringUtils.compare("b", "a") > 0); 202 assertTrue(StringUtils.compare("a", "B") > 0); 203 assertTrue(StringUtils.compare("abc", "abd") < 0); 204 assertTrue(StringUtils.compare("ab", "abc") < 0); 205 assertTrue(StringUtils.compare("ab", "ab ") < 0); 206 assertTrue(StringUtils.compare("abc", "ab ") > 0); 207 } 208 209 @Test 210 public void testCompare_StringStringBoolean() { 211 assertEquals(0, StringUtils.compare(null, null, false)); 212 assertTrue(StringUtils.compare(null, "a", true) < 0); 213 assertTrue(StringUtils.compare(null, "a", false) > 0); 214 assertTrue(StringUtils.compare("a", null, true) > 0); 215 assertTrue(StringUtils.compare("a", null, false) < 0); 216 assertEquals(0, StringUtils.compare("abc", "abc", false)); 217 assertTrue(StringUtils.compare("a", "b", false) < 0); 218 assertTrue(StringUtils.compare("b", "a", false) > 0); 219 assertTrue(StringUtils.compare("a", "B", false) > 0); 220 assertTrue(StringUtils.compare("abc", "abd", false) < 0); 221 assertTrue(StringUtils.compare("ab", "abc", false) < 0); 222 assertTrue(StringUtils.compare("ab", "ab ", false) < 0); 223 assertTrue(StringUtils.compare("abc", "ab ", false) > 0); 224 } 225 226 @Test 227 public void testCompareIgnoreCase_StringString() { 228 assertEquals(0, StringUtils.compareIgnoreCase(null, null)); 229 assertTrue(StringUtils.compareIgnoreCase(null, "a") < 0); 230 assertTrue(StringUtils.compareIgnoreCase("a", null) > 0); 231 assertEquals(0, StringUtils.compareIgnoreCase("abc", "abc")); 232 assertEquals(0, StringUtils.compareIgnoreCase("abc", "ABC")); 233 assertTrue(StringUtils.compareIgnoreCase("a", "b") < 0); 234 assertTrue(StringUtils.compareIgnoreCase("b", "a") > 0); 235 assertTrue(StringUtils.compareIgnoreCase("a", "B") < 0); 236 assertTrue(StringUtils.compareIgnoreCase("A", "b") < 0); 237 assertTrue(StringUtils.compareIgnoreCase("abc", "ABD") < 0); 238 assertTrue(StringUtils.compareIgnoreCase("ab", "ABC") < 0); 239 assertTrue(StringUtils.compareIgnoreCase("ab", "AB ") < 0); 240 assertTrue(StringUtils.compareIgnoreCase("abc", "AB ") > 0); 241 } 242 243 @Test 244 public void testCompareIgnoreCase_StringStringBoolean() { 245 assertEquals(0, StringUtils.compareIgnoreCase(null, null, false)); 246 assertTrue(StringUtils.compareIgnoreCase(null, "a", true) < 0); 247 assertTrue(StringUtils.compareIgnoreCase(null, "a", false) > 0); 248 assertTrue(StringUtils.compareIgnoreCase("a", null, true) > 0); 249 assertTrue(StringUtils.compareIgnoreCase("a", null, false) < 0); 250 assertEquals(0, StringUtils.compareIgnoreCase("abc", "abc", false)); 251 assertEquals(0, StringUtils.compareIgnoreCase("abc", "ABC", false)); 252 assertTrue(StringUtils.compareIgnoreCase("a", "b", false) < 0); 253 assertTrue(StringUtils.compareIgnoreCase("b", "a", false) > 0); 254 assertTrue(StringUtils.compareIgnoreCase("a", "B", false) < 0); 255 assertTrue(StringUtils.compareIgnoreCase("A", "b", false) < 0); 256 assertTrue(StringUtils.compareIgnoreCase("abc", "ABD", false) < 0); 257 assertTrue(StringUtils.compareIgnoreCase("ab", "ABC", false) < 0); 258 assertTrue(StringUtils.compareIgnoreCase("ab", "AB ", false) < 0); 259 assertTrue(StringUtils.compareIgnoreCase("abc", "AB ", false) > 0); 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 testLastIndexOf_char() { 515 assertEquals(-1, StringUtils.lastIndexOf(null, ' ')); 516 assertEquals(-1, StringUtils.lastIndexOf("", ' ')); 517 assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a')); 518 assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b')); 519 520 assertEquals(5, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b')); 521 } 522 523 @Test 524 public void testLastIndexOf_charInt() { 525 assertEquals(-1, StringUtils.lastIndexOf(null, ' ', 0)); 526 assertEquals(-1, StringUtils.lastIndexOf(null, ' ', -1)); 527 assertEquals(-1, StringUtils.lastIndexOf("", ' ', 0)); 528 assertEquals(-1, StringUtils.lastIndexOf("", ' ', -1)); 529 assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a', 8)); 530 assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 8)); 531 assertEquals(2, StringUtils.lastIndexOf("aabaabaa", 'b', 3)); 532 assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 9)); 533 assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", 'b', -1)); 534 assertEquals(0, StringUtils.lastIndexOf("aabaabaa", 'a', 0)); 535 536 assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b', 2)); 537 538 //LANG-1300 addition test 539 final int CODE_POINT = 0x2070E; 540 StringBuilder builder = new StringBuilder(); 541 builder.appendCodePoint(CODE_POINT); 542 assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); 543 builder.appendCodePoint(CODE_POINT); 544 assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); 545 assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 1)); 546 assertEquals(2, StringUtils.lastIndexOf(builder, CODE_POINT, 2)); 547 548 builder.append("aaaaa"); 549 assertEquals(2, StringUtils.lastIndexOf(builder, CODE_POINT, 4)); 550 // inner branch on the supplementary character block 551 final char[] tmp = { (char) 55361 }; 552 builder = new StringBuilder(); 553 builder.append(tmp); 554 assertEquals(-1, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); 555 builder.appendCodePoint(CODE_POINT); 556 assertEquals(-1, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); 557 assertEquals(1, StringUtils.lastIndexOf(builder, CODE_POINT, 1 )); 558 assertEquals(-1, StringUtils.lastIndexOf(builder.toString(), CODE_POINT, 0)); 559 assertEquals(1, StringUtils.lastIndexOf(builder.toString(), CODE_POINT, 1)); 560 assertEquals(StringUtils.INDEX_NOT_FOUND, StringUtils.lastIndexOf(CharBuffer.wrap("[%{.c.0rro"), -1738, 982)); 561 } 562 563 @Test 564 public void testLastIndexOf_String() { 565 assertEquals(-1, StringUtils.lastIndexOf(null, null)); 566 assertEquals(-1, StringUtils.lastIndexOf("", null)); 567 assertEquals(-1, StringUtils.lastIndexOf("", "a")); 568 assertEquals(0, StringUtils.lastIndexOf("", "")); 569 assertEquals(8, StringUtils.lastIndexOf("aabaabaa", "")); 570 assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a")); 571 assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b")); 572 assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab")); 573 574 assertEquals(4, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "ab")); 575 } 576 577 @Test 578 public void testLastIndexOf_StringInt() { 579 assertEquals(-1, StringUtils.lastIndexOf(null, null, 0)); 580 assertEquals(-1, StringUtils.lastIndexOf(null, null, -1)); 581 assertEquals(-1, StringUtils.lastIndexOf(null, "", 0)); 582 assertEquals(-1, StringUtils.lastIndexOf(null, "", -1)); 583 assertEquals(-1, StringUtils.lastIndexOf("", null, 0)); 584 assertEquals(-1, StringUtils.lastIndexOf("", null, -1)); 585 assertEquals(0, StringUtils.lastIndexOf("", "", 0)); 586 assertEquals(-1, StringUtils.lastIndexOf("", "", -1)); 587 assertEquals(0, StringUtils.lastIndexOf("", "", 9)); 588 assertEquals(0, StringUtils.lastIndexOf("abc", "", 0)); 589 assertEquals(-1, StringUtils.lastIndexOf("abc", "", -1)); 590 assertEquals(3, StringUtils.lastIndexOf("abc", "", 9)); 591 assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a", 8)); 592 assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 8)); 593 assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab", 8)); 594 assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 3)); 595 assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 9)); 596 assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", -1)); 597 assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 0)); 598 assertEquals(0, StringUtils.lastIndexOf("aabaabaa", "a", 0)); 599 assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "a", -1)); 600 601 // Test that fromIndex works correctly, i.e. cannot match after fromIndex 602 assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 9)); 603 assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 8)); 604 assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 7)); // 7 is last index 605 assertEquals(-1, StringUtils.lastIndexOf("12345678", "8", 6)); 606 607 assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 1)); 608 assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 2)); 609 assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 2)); 610 assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 3)); 611 612 assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "b", 3)); 613 } 614 615 @Test 616 public void testLastIndexOfAny_StringStringArray() { 617 assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence) null)); // test both types of ... 618 assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence[]) null)); // ... varargs invocation 619 assertEquals(-1, StringUtils.lastIndexOfAny(null)); // Missing varag 620 assertEquals(-1, StringUtils.lastIndexOfAny(null, FOOBAR_SUB_ARRAY)); 621 assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence) null)); // test both types of ... 622 assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence[]) null)); // ... varargs invocation 623 assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR)); // Missing vararg 624 assertEquals(3, StringUtils.lastIndexOfAny(FOOBAR, FOOBAR_SUB_ARRAY)); 625 assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[0])); 626 assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[0])); 627 assertEquals(-1, StringUtils.lastIndexOfAny("", new String[0])); 628 assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {"llll"})); 629 assertEquals(6, StringUtils.lastIndexOfAny(FOOBAR, new String[] {""})); 630 assertEquals(0, StringUtils.lastIndexOfAny("", new String[] {""})); 631 assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {"a"})); 632 assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {null})); 633 assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {null})); 634 assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[] {null})); 635 } 636 637 @Test 638 public void testLastIndexOfIgnoreCase_String() { 639 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null)); 640 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null)); 641 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "")); 642 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "a")); 643 assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "")); 644 assertEquals(8, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "")); 645 assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "a")); 646 assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A")); 647 assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "b")); 648 assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B")); 649 assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "ab")); 650 assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB")); 651 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("ab", "AAB")); 652 assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aab", "AAB")); 653 } 654 655 @Test 656 public void testLastIndexOfIgnoreCase_StringInt() { 657 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, 0)); 658 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, -1)); 659 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", 0)); 660 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", -1)); 661 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, 0)); 662 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, -1)); 663 assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 0)); 664 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "", -1)); 665 assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 9)); 666 assertEquals(0, StringUtils.lastIndexOfIgnoreCase("abc", "", 0)); 667 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("abc", "", -1)); 668 assertEquals(3, StringUtils.lastIndexOfIgnoreCase("abc", "", 9)); 669 assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8)); 670 assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8)); 671 assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8)); 672 assertEquals(2, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 3)); 673 assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9)); 674 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1)); 675 assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0)); 676 assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0)); 677 assertEquals(1, StringUtils.lastIndexOfIgnoreCase("aab", "AB", 1)); 678 } 679 680 @Test 681 public void testLastOrdinalIndexOf() { 682 assertEquals(-1, StringUtils.lastOrdinalIndexOf(null, "*", 42) ); 683 assertEquals(-1, StringUtils.lastOrdinalIndexOf("*", null, 42) ); 684 assertEquals(0, StringUtils.lastOrdinalIndexOf("", "", 42) ); 685 assertEquals(7, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1) ); 686 assertEquals(6, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2) ); 687 assertEquals(5, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1) ); 688 assertEquals(2, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2) ); 689 assertEquals(4, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) ); 690 assertEquals(1, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) ); 691 assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1) ); 692 assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2) ); 693 } 694 695 @Test 696 public void testOrdinalIndexOf() { 697 assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MIN_VALUE)); 698 assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MIN_VALUE)); 699 assertEquals(-1, StringUtils.ordinalIndexOf("", "", Integer.MIN_VALUE)); 700 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MIN_VALUE)); 701 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MIN_VALUE)); 702 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MIN_VALUE)); 703 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MIN_VALUE)); 704 705 assertEquals(-1, StringUtils.ordinalIndexOf(null, null, -1)); 706 assertEquals(-1, StringUtils.ordinalIndexOf("", null, -1)); 707 assertEquals(-1, StringUtils.ordinalIndexOf("", "", -1)); 708 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", -1)); 709 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", -1)); 710 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", -1)); 711 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", -1)); 712 713 assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 0)); 714 assertEquals(-1, StringUtils.ordinalIndexOf("", null, 0)); 715 assertEquals(-1, StringUtils.ordinalIndexOf("", "", 0)); 716 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", 0)); 717 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", 0)); 718 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 0)); 719 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", 0)); 720 721 assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 1)); 722 assertEquals(-1, StringUtils.ordinalIndexOf("", null, 1)); 723 assertEquals(0, StringUtils.ordinalIndexOf("", "", 1)); 724 assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "a", 1)); 725 assertEquals(2, StringUtils.ordinalIndexOf("aabaabaa", "b", 1)); 726 assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 1)); 727 assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 1)); 728 729 assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 2)); 730 assertEquals(-1, StringUtils.ordinalIndexOf("", null, 2)); 731 assertEquals(0, StringUtils.ordinalIndexOf("", "", 2)); 732 assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "a", 2)); 733 assertEquals(5, StringUtils.ordinalIndexOf("aabaabaa", "b", 2)); 734 assertEquals(4, StringUtils.ordinalIndexOf("aabaabaa", "ab", 2)); 735 assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 2)); 736 737 assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MAX_VALUE)); 738 assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MAX_VALUE)); 739 assertEquals(0, StringUtils.ordinalIndexOf("", "", Integer.MAX_VALUE)); 740 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MAX_VALUE)); 741 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MAX_VALUE)); 742 assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MAX_VALUE)); 743 assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MAX_VALUE)); 744 745 assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 0)); 746 assertEquals(0, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 1)); 747 assertEquals(1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 2)); 748 assertEquals(2, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 3)); 749 assertEquals(3, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 4)); 750 assertEquals(4, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 5)); 751 assertEquals(5, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 6)); 752 assertEquals(6, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 7)); 753 assertEquals(7, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 8)); 754 assertEquals(8, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 9)); 755 assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 10)); 756 757 // match at each possible position 758 assertEquals(0, StringUtils.ordinalIndexOf("aaaaaa", "aa", 1)); 759 assertEquals(1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 2)); 760 assertEquals(2, StringUtils.ordinalIndexOf("aaaaaa", "aa", 3)); 761 assertEquals(3, StringUtils.ordinalIndexOf("aaaaaa", "aa", 4)); 762 assertEquals(4, StringUtils.ordinalIndexOf("aaaaaa", "aa", 5)); 763 assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 6)); 764 765 assertEquals(0, StringUtils.ordinalIndexOf("ababab", "aba", 1)); 766 assertEquals(2, StringUtils.ordinalIndexOf("ababab", "aba", 2)); 767 assertEquals(-1, StringUtils.ordinalIndexOf("ababab", "aba", 3)); 768 769 assertEquals(0, StringUtils.ordinalIndexOf("abababab", "abab", 1)); 770 assertEquals(2, StringUtils.ordinalIndexOf("abababab", "abab", 2)); 771 assertEquals(4, StringUtils.ordinalIndexOf("abababab", "abab", 3)); 772 assertEquals(-1, StringUtils.ordinalIndexOf("abababab", "abab", 4)); 773 } 774 775 @Test 776 public void testLANG1193() { 777 assertEquals(0, StringUtils.ordinalIndexOf("abc", "ab", 1)); 778 } 779 780 @Test 781 // Non-overlapping test 782 public void testLANG1241_1() { 783 // 0 3 6 784 assertEquals(0, StringUtils.ordinalIndexOf("abaabaab", "ab", 1)); 785 assertEquals(3, StringUtils.ordinalIndexOf("abaabaab", "ab", 2)); 786 assertEquals(6, StringUtils.ordinalIndexOf("abaabaab", "ab", 3)); 787 } 788 789 @Test 790 // Overlapping matching test 791 public void testLANG1241_2() { 792 // 0 2 4 793 assertEquals(0, StringUtils.ordinalIndexOf("abababa", "aba", 1)); 794 assertEquals(2, StringUtils.ordinalIndexOf("abababa", "aba", 2)); 795 assertEquals(4, StringUtils.ordinalIndexOf("abababa", "aba", 3)); 796 assertEquals(0, StringUtils.ordinalIndexOf("abababab", "abab", 1)); 797 assertEquals(2, StringUtils.ordinalIndexOf("abababab", "abab", 2)); 798 assertEquals(4, StringUtils.ordinalIndexOf("abababab", "abab", 3)); 799 } 800 } 801