/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.lang3; import static org.apache.commons.lang3.Supplementary.CharU20000; import static org.apache.commons.lang3.Supplementary.CharU20001; import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import java.nio.CharBuffer; import java.util.Locale; import org.hamcrest.core.IsNot; import org.junit.jupiter.api.Test; /** * Unit tests {@link org.apache.commons.lang3.StringUtils} - Equals/IndexOf methods */ public class StringUtilsEqualsIndexOfTest extends AbstractLangTest { private static final String BAR = "bar"; private static final String FOO = "foo"; private static final String FOOBAR = "foobar"; private static final String[] FOOBAR_SUB_ARRAY = {"ob", "ba"}; // The purpose of this class is to test StringUtils#equals(CharSequence, CharSequence) // with a CharSequence implementation whose equals(Object) override requires that the // other object be an instance of CustomCharSequence, even though, as char sequences, // `seq` may equal the other object. private static class CustomCharSequence implements CharSequence { private final CharSequence seq; CustomCharSequence(final CharSequence seq) { this.seq = seq; } @Override public char charAt(final int index) { return seq.charAt(index); } @Override public int length() { return seq.length(); } @Override public CharSequence subSequence(final int start, final int end) { return new CustomCharSequence(seq.subSequence(start, end)); } @Override public boolean equals(final Object obj) { if (!(obj instanceof CustomCharSequence)) { return false; } final CustomCharSequence other = (CustomCharSequence) obj; return seq.equals(other.seq); } @Override public int hashCode() { return seq.hashCode(); } @Override public String toString() { return seq.toString(); } } @Test public void testCustomCharSequence() { assertThat(new CustomCharSequence(FOO), IsNot.not(FOO)); assertThat(FOO, IsNot.not(new CustomCharSequence(FOO))); assertEquals(new CustomCharSequence(FOO), new CustomCharSequence(FOO)); } @Test public void testEquals() { final CharSequence fooCs = new StringBuilder(FOO), barCs = new StringBuilder(BAR), foobarCs = new StringBuilder(FOOBAR); assertTrue(StringUtils.equals(null, null)); assertTrue(StringUtils.equals(fooCs, fooCs)); assertTrue(StringUtils.equals(fooCs, new StringBuilder(FOO))); assertTrue(StringUtils.equals(fooCs, new String(new char[] { 'f', 'o', 'o' }))); assertTrue(StringUtils.equals(fooCs, new CustomCharSequence(FOO))); assertTrue(StringUtils.equals(new CustomCharSequence(FOO), fooCs)); assertFalse(StringUtils.equals(fooCs, new String(new char[] { 'f', 'O', 'O' }))); assertFalse(StringUtils.equals(fooCs, barCs)); assertFalse(StringUtils.equals(fooCs, null)); assertFalse(StringUtils.equals(null, fooCs)); assertFalse(StringUtils.equals(fooCs, foobarCs)); assertFalse(StringUtils.equals(foobarCs, fooCs)); } @Test public void testEqualsOnStrings() { assertTrue(StringUtils.equals(null, null)); assertTrue(StringUtils.equals(FOO, FOO)); assertTrue(StringUtils.equals(FOO, new String(new char[] { 'f', 'o', 'o' }))); assertFalse(StringUtils.equals(FOO, new String(new char[] { 'f', 'O', 'O' }))); assertFalse(StringUtils.equals(FOO, BAR)); assertFalse(StringUtils.equals(FOO, null)); assertFalse(StringUtils.equals(null, FOO)); assertFalse(StringUtils.equals(FOO, FOOBAR)); assertFalse(StringUtils.equals(FOOBAR, FOO)); } @Test public void testEqualsIgnoreCase() { assertTrue(StringUtils.equalsIgnoreCase(null, null)); assertTrue(StringUtils.equalsIgnoreCase(FOO, FOO)); assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'o', 'o' }))); assertTrue(StringUtils.equalsIgnoreCase(FOO, new String(new char[] { 'f', 'O', 'O' }))); assertFalse(StringUtils.equalsIgnoreCase(FOO, BAR)); assertFalse(StringUtils.equalsIgnoreCase(FOO, null)); assertFalse(StringUtils.equalsIgnoreCase(null, FOO)); assertTrue(StringUtils.equalsIgnoreCase("", "")); assertFalse(StringUtils.equalsIgnoreCase("abcd", "abcd ")); } @Test public void testEqualsAny() { assertFalse(StringUtils.equalsAny(FOO)); assertFalse(StringUtils.equalsAny(FOO, new String[]{})); assertTrue(StringUtils.equalsAny(FOO, FOO)); assertTrue(StringUtils.equalsAny(FOO, BAR, new String(new char[] { 'f', 'o', 'o' }))); assertFalse(StringUtils.equalsAny(FOO, BAR, new String(new char[] { 'f', 'O', 'O' }))); assertFalse(StringUtils.equalsAny(FOO, BAR)); assertFalse(StringUtils.equalsAny(FOO, BAR, null)); assertFalse(StringUtils.equalsAny(null, FOO)); assertFalse(StringUtils.equalsAny(FOO, FOOBAR)); assertFalse(StringUtils.equalsAny(FOOBAR, FOO)); assertTrue(StringUtils.equalsAny(null, null, null)); assertFalse(StringUtils.equalsAny(null, FOO, BAR, FOOBAR)); assertFalse(StringUtils.equalsAny(FOO, null, BAR)); assertTrue(StringUtils.equalsAny(FOO, BAR, null, "", FOO, BAR)); assertFalse(StringUtils.equalsAny(FOO, FOO.toUpperCase(Locale.ROOT))); assertFalse(StringUtils.equalsAny(null, (CharSequence[]) null)); assertTrue(StringUtils.equalsAny(FOO, new CustomCharSequence("foo"))); assertTrue(StringUtils.equalsAny(FOO, new StringBuilder("foo"))); assertFalse(StringUtils.equalsAny(FOO, new CustomCharSequence("fOo"))); assertFalse(StringUtils.equalsAny(FOO, new StringBuilder("fOo"))); } @Test public void testEqualsAnyIgnoreCase() { assertFalse(StringUtils.equalsAnyIgnoreCase(FOO)); assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, new String[]{})); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO)); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO.toUpperCase(Locale.ROOT))); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO, new String(new char[]{'f', 'o', 'o'}))); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, BAR, new String(new char[]{'f', 'O', 'O'}))); assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, BAR)); assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, BAR, null)); assertFalse(StringUtils.equalsAnyIgnoreCase(null, FOO)); assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, FOOBAR)); assertFalse(StringUtils.equalsAnyIgnoreCase(FOOBAR, FOO)); assertTrue(StringUtils.equalsAnyIgnoreCase(null, null, null)); assertFalse(StringUtils.equalsAnyIgnoreCase(null, FOO, BAR, FOOBAR)); assertFalse(StringUtils.equalsAnyIgnoreCase(FOO, null, BAR)); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, BAR, null, "", FOO.toUpperCase(Locale.ROOT), BAR)); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, FOO.toUpperCase(Locale.ROOT))); assertFalse(StringUtils.equalsAnyIgnoreCase(null, (CharSequence[]) null)); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new CustomCharSequence("fOo"))); assertTrue(StringUtils.equalsAnyIgnoreCase(FOO, new StringBuilder("fOo"))); } @Test public void testCompare_StringString() { assertEquals(0, StringUtils.compare(null, null)); assertTrue(StringUtils.compare(null, "a") < 0); assertTrue(StringUtils.compare("a", null) > 0); assertEquals(0, StringUtils.compare("abc", "abc")); assertTrue(StringUtils.compare("a", "b") < 0); assertTrue(StringUtils.compare("b", "a") > 0); assertTrue(StringUtils.compare("a", "B") > 0); assertTrue(StringUtils.compare("abc", "abd") < 0); assertTrue(StringUtils.compare("ab", "abc") < 0); assertTrue(StringUtils.compare("ab", "ab ") < 0); assertTrue(StringUtils.compare("abc", "ab ") > 0); } @Test public void testCompare_StringStringBoolean() { assertEquals(0, StringUtils.compare(null, null, false)); assertTrue(StringUtils.compare(null, "a", true) < 0); assertTrue(StringUtils.compare(null, "a", false) > 0); assertTrue(StringUtils.compare("a", null, true) > 0); assertTrue(StringUtils.compare("a", null, false) < 0); assertEquals(0, StringUtils.compare("abc", "abc", false)); assertTrue(StringUtils.compare("a", "b", false) < 0); assertTrue(StringUtils.compare("b", "a", false) > 0); assertTrue(StringUtils.compare("a", "B", false) > 0); assertTrue(StringUtils.compare("abc", "abd", false) < 0); assertTrue(StringUtils.compare("ab", "abc", false) < 0); assertTrue(StringUtils.compare("ab", "ab ", false) < 0); assertTrue(StringUtils.compare("abc", "ab ", false) > 0); } @Test public void testCompareIgnoreCase_StringString() { assertEquals(0, StringUtils.compareIgnoreCase(null, null)); assertTrue(StringUtils.compareIgnoreCase(null, "a") < 0); assertTrue(StringUtils.compareIgnoreCase("a", null) > 0); assertEquals(0, StringUtils.compareIgnoreCase("abc", "abc")); assertEquals(0, StringUtils.compareIgnoreCase("abc", "ABC")); assertTrue(StringUtils.compareIgnoreCase("a", "b") < 0); assertTrue(StringUtils.compareIgnoreCase("b", "a") > 0); assertTrue(StringUtils.compareIgnoreCase("a", "B") < 0); assertTrue(StringUtils.compareIgnoreCase("A", "b") < 0); assertTrue(StringUtils.compareIgnoreCase("abc", "ABD") < 0); assertTrue(StringUtils.compareIgnoreCase("ab", "ABC") < 0); assertTrue(StringUtils.compareIgnoreCase("ab", "AB ") < 0); assertTrue(StringUtils.compareIgnoreCase("abc", "AB ") > 0); } @Test public void testCompareIgnoreCase_StringStringBoolean() { assertEquals(0, StringUtils.compareIgnoreCase(null, null, false)); assertTrue(StringUtils.compareIgnoreCase(null, "a", true) < 0); assertTrue(StringUtils.compareIgnoreCase(null, "a", false) > 0); assertTrue(StringUtils.compareIgnoreCase("a", null, true) > 0); assertTrue(StringUtils.compareIgnoreCase("a", null, false) < 0); assertEquals(0, StringUtils.compareIgnoreCase("abc", "abc", false)); assertEquals(0, StringUtils.compareIgnoreCase("abc", "ABC", false)); assertTrue(StringUtils.compareIgnoreCase("a", "b", false) < 0); assertTrue(StringUtils.compareIgnoreCase("b", "a", false) > 0); assertTrue(StringUtils.compareIgnoreCase("a", "B", false) < 0); assertTrue(StringUtils.compareIgnoreCase("A", "b", false) < 0); assertTrue(StringUtils.compareIgnoreCase("abc", "ABD", false) < 0); assertTrue(StringUtils.compareIgnoreCase("ab", "ABC", false) < 0); assertTrue(StringUtils.compareIgnoreCase("ab", "AB ", false) < 0); assertTrue(StringUtils.compareIgnoreCase("abc", "AB ", false) > 0); } @Test public void testIndexOf_char() { assertEquals(-1, StringUtils.indexOf(null, ' ')); assertEquals(-1, StringUtils.indexOf("", ' ')); assertEquals(0, StringUtils.indexOf("aabaabaa", 'a')); assertEquals(2, StringUtils.indexOf("aabaabaa", 'b')); assertEquals(2, StringUtils.indexOf(new StringBuilder("aabaabaa"), 'b')); assertEquals(StringUtils.INDEX_NOT_FOUND, StringUtils.indexOf(new StringBuilder("aabaabaa"), -1738)); } @Test public void testIndexOf_charInt() { assertEquals(-1, StringUtils.indexOf(null, ' ', 0)); assertEquals(-1, StringUtils.indexOf(null, ' ', -1)); assertEquals(-1, StringUtils.indexOf("", ' ', 0)); assertEquals(-1, StringUtils.indexOf("", ' ', -1)); assertEquals(0, StringUtils.indexOf("aabaabaa", 'a', 0)); assertEquals(2, StringUtils.indexOf("aabaabaa", 'b', 0)); assertEquals(5, StringUtils.indexOf("aabaabaa", 'b', 3)); assertEquals(-1, StringUtils.indexOf("aabaabaa", 'b', 9)); assertEquals(2, StringUtils.indexOf("aabaabaa", 'b', -1)); assertEquals(5, StringUtils.indexOf(new StringBuilder("aabaabaa"), 'b', 3)); //LANG-1300 tests go here final int CODE_POINT = 0x2070E; StringBuilder builder = new StringBuilder(); builder.appendCodePoint(CODE_POINT); assertEquals(0, StringUtils.indexOf(builder, CODE_POINT, 0)); assertEquals(0, StringUtils.indexOf(builder.toString(), CODE_POINT, 0)); builder.appendCodePoint(CODE_POINT); assertEquals(2, StringUtils.indexOf(builder, CODE_POINT, 1)); assertEquals(2, StringUtils.indexOf(builder.toString(), CODE_POINT, 1)); // inner branch on the supplementary character block final char[] tmp = { (char) 55361 }; builder = new StringBuilder(); builder.append(tmp); assertEquals(-1, StringUtils.indexOf(builder, CODE_POINT, 0)); assertEquals(-1, StringUtils.indexOf(builder.toString(), CODE_POINT, 0)); builder.appendCodePoint(CODE_POINT); assertEquals(1, StringUtils.indexOf(builder, CODE_POINT, 0)); assertEquals(1, StringUtils.indexOf(builder.toString(), CODE_POINT, 0)); assertEquals(-1, StringUtils.indexOf(builder, CODE_POINT, 2)); assertEquals(-1, StringUtils.indexOf(builder.toString(), CODE_POINT, 2)); } @Test public void testIndexOf_String() { assertEquals(-1, StringUtils.indexOf(null, null)); assertEquals(-1, StringUtils.indexOf("", null)); assertEquals(0, StringUtils.indexOf("", "")); assertEquals(0, StringUtils.indexOf("aabaabaa", "a")); assertEquals(2, StringUtils.indexOf("aabaabaa", "b")); assertEquals(1, StringUtils.indexOf("aabaabaa", "ab")); assertEquals(0, StringUtils.indexOf("aabaabaa", "")); assertEquals(2, StringUtils.indexOf(new StringBuilder("aabaabaa"), "b")); } @Test public void testIndexOf_StringInt() { assertEquals(-1, StringUtils.indexOf(null, null, 0)); assertEquals(-1, StringUtils.indexOf(null, null, -1)); assertEquals(-1, StringUtils.indexOf(null, "", 0)); assertEquals(-1, StringUtils.indexOf(null, "", -1)); assertEquals(-1, StringUtils.indexOf("", null, 0)); assertEquals(-1, StringUtils.indexOf("", null, -1)); assertEquals(0, StringUtils.indexOf("", "", 0)); assertEquals(0, StringUtils.indexOf("", "", -1)); assertEquals(0, StringUtils.indexOf("", "", 9)); assertEquals(0, StringUtils.indexOf("abc", "", 0)); assertEquals(0, StringUtils.indexOf("abc", "", -1)); assertEquals(3, StringUtils.indexOf("abc", "", 9)); assertEquals(3, StringUtils.indexOf("abc", "", 3)); assertEquals(0, StringUtils.indexOf("aabaabaa", "a", 0)); assertEquals(2, StringUtils.indexOf("aabaabaa", "b", 0)); assertEquals(1, StringUtils.indexOf("aabaabaa", "ab", 0)); assertEquals(5, StringUtils.indexOf("aabaabaa", "b", 3)); assertEquals(-1, StringUtils.indexOf("aabaabaa", "b", 9)); assertEquals(2, StringUtils.indexOf("aabaabaa", "b", -1)); assertEquals(2, StringUtils.indexOf("aabaabaa", "", 2)); // Test that startIndex works correctly, i.e. cannot match before startIndex assertEquals(7, StringUtils.indexOf("12345678", "8", 5)); assertEquals(7, StringUtils.indexOf("12345678", "8", 6)); assertEquals(7, StringUtils.indexOf("12345678", "8", 7)); // 7 is last index assertEquals(-1, StringUtils.indexOf("12345678", "8", 8)); assertEquals(5, StringUtils.indexOf(new StringBuilder("aabaabaa"), "b", 3)); } @Test public void testIndexOfAny_StringCharArray() { assertEquals(-1, StringUtils.indexOfAny(null, (char[]) null)); assertEquals(-1, StringUtils.indexOfAny(null, new char[0])); assertEquals(-1, StringUtils.indexOfAny(null, 'a', 'b')); assertEquals(-1, StringUtils.indexOfAny("", (char[]) null)); assertEquals(-1, StringUtils.indexOfAny("", new char[0])); assertEquals(-1, StringUtils.indexOfAny("", 'a', 'b')); assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", (char[]) null)); assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", new char[0])); assertEquals(0, StringUtils.indexOfAny("zzabyycdxx", 'z', 'a')); assertEquals(3, StringUtils.indexOfAny("zzabyycdxx", 'b', 'y')); assertEquals(-1, StringUtils.indexOfAny("ab", 'z')); } /** * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html */ @Test public void testIndexOfAny_StringCharArrayWithSupplementaryChars() { assertEquals(0, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20000.toCharArray())); assertEquals(2, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20001.toCharArray())); assertEquals(0, StringUtils.indexOfAny(CharU20000, CharU20000.toCharArray())); assertEquals(-1, StringUtils.indexOfAny(CharU20000, CharU20001.toCharArray())); } @Test public void testIndexOfAny_StringString() { assertEquals(-1, StringUtils.indexOfAny(null, (String) null)); assertEquals(-1, StringUtils.indexOfAny(null, "")); assertEquals(-1, StringUtils.indexOfAny(null, "ab")); assertEquals(-1, StringUtils.indexOfAny("", (String) null)); assertEquals(-1, StringUtils.indexOfAny("", "")); assertEquals(-1, StringUtils.indexOfAny("", "ab")); assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", (String) null)); assertEquals(-1, StringUtils.indexOfAny("zzabyycdxx", "")); assertEquals(0, StringUtils.indexOfAny("zzabyycdxx", "za")); assertEquals(3, StringUtils.indexOfAny("zzabyycdxx", "by")); assertEquals(-1, StringUtils.indexOfAny("ab", "z")); } @Test public void testIndexOfAny_StringStringArray() { assertEquals(-1, StringUtils.indexOfAny(null, (String[]) null)); assertEquals(-1, StringUtils.indexOfAny(null, FOOBAR_SUB_ARRAY)); assertEquals(-1, StringUtils.indexOfAny(FOOBAR, (String[]) null)); assertEquals(2, StringUtils.indexOfAny(FOOBAR, FOOBAR_SUB_ARRAY)); assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[0])); assertEquals(-1, StringUtils.indexOfAny(null, new String[0])); assertEquals(-1, StringUtils.indexOfAny("", new String[0])); assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[] {"llll"})); assertEquals(0, StringUtils.indexOfAny(FOOBAR, new String[] {""})); assertEquals(0, StringUtils.indexOfAny("", new String[] {""})); assertEquals(-1, StringUtils.indexOfAny("", new String[] {"a"})); assertEquals(-1, StringUtils.indexOfAny("", new String[] {null})); assertEquals(-1, StringUtils.indexOfAny(FOOBAR, new String[] {null})); assertEquals(-1, StringUtils.indexOfAny(null, new String[] {null})); } /** * See https://www.oracle.com/technical-resources/articles/javase/supplementary.html */ @Test public void testIndexOfAny_StringStringWithSupplementaryChars() { assertEquals(0, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20000)); assertEquals(2, StringUtils.indexOfAny(CharU20000 + CharU20001, CharU20001)); assertEquals(0, StringUtils.indexOfAny(CharU20000, CharU20000)); assertEquals(-1, StringUtils.indexOfAny(CharU20000, CharU20001)); } @Test public void testIndexOfAnyBut_StringCharArray() { assertEquals(-1, StringUtils.indexOfAnyBut(null, (char[]) null)); assertEquals(-1, StringUtils.indexOfAnyBut(null)); assertEquals(-1, StringUtils.indexOfAnyBut(null, 'a', 'b')); assertEquals(-1, StringUtils.indexOfAnyBut("", (char[]) null)); assertEquals(-1, StringUtils.indexOfAnyBut("")); assertEquals(-1, StringUtils.indexOfAnyBut("", 'a', 'b')); assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", (char[]) null)); assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx")); assertEquals(3, StringUtils.indexOfAnyBut("zzabyycdxx", 'z', 'a')); assertEquals(0, StringUtils.indexOfAnyBut("zzabyycdxx", 'b', 'y')); assertEquals(-1, StringUtils.indexOfAnyBut("aba", 'a', 'b')); assertEquals(0, StringUtils.indexOfAnyBut("aba", 'z')); } @Test public void testIndexOfAnyBut_StringCharArrayWithSupplementaryChars() { assertEquals(2, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20000.toCharArray())); assertEquals(0, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20001.toCharArray())); assertEquals(-1, StringUtils.indexOfAnyBut(CharU20000, CharU20000.toCharArray())); assertEquals(0, StringUtils.indexOfAnyBut(CharU20000, CharU20001.toCharArray())); } @Test public void testIndexOfAnyBut_StringString() { assertEquals(-1, StringUtils.indexOfAnyBut(null, (String) null)); assertEquals(-1, StringUtils.indexOfAnyBut(null, "")); assertEquals(-1, StringUtils.indexOfAnyBut(null, "ab")); assertEquals(-1, StringUtils.indexOfAnyBut("", (String) null)); assertEquals(-1, StringUtils.indexOfAnyBut("", "")); assertEquals(-1, StringUtils.indexOfAnyBut("", "ab")); assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", (String) null)); assertEquals(-1, StringUtils.indexOfAnyBut("zzabyycdxx", "")); assertEquals(3, StringUtils.indexOfAnyBut("zzabyycdxx", "za")); assertEquals(0, StringUtils.indexOfAnyBut("zzabyycdxx", "by")); assertEquals(0, StringUtils.indexOfAnyBut("ab", "z")); } @Test public void testIndexOfAnyBut_StringStringWithSupplementaryChars() { assertEquals(2, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20000)); assertEquals(0, StringUtils.indexOfAnyBut(CharU20000 + CharU20001, CharU20001)); assertEquals(-1, StringUtils.indexOfAnyBut(CharU20000, CharU20000)); assertEquals(0, StringUtils.indexOfAnyBut(CharU20000, CharU20001)); } @Test public void testIndexOfIgnoreCase_String() { assertEquals(-1, StringUtils.indexOfIgnoreCase(null, null)); assertEquals(-1, StringUtils.indexOfIgnoreCase(null, "")); assertEquals(-1, StringUtils.indexOfIgnoreCase("", null)); assertEquals(0, StringUtils.indexOfIgnoreCase("", "")); assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "a")); assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "A")); assertEquals(2, StringUtils.indexOfIgnoreCase("aabaabaa", "b")); assertEquals(2, StringUtils.indexOfIgnoreCase("aabaabaa", "B")); assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "ab")); assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB")); assertEquals(0, StringUtils.indexOfIgnoreCase("aabaabaa", "")); } @Test public void testIndexOfIgnoreCase_StringInt() { assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", -1)); assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 0)); assertEquals(1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 1)); assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 2)); assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 3)); assertEquals(4, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 4)); assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 5)); assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 6)); assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 7)); assertEquals(-1, StringUtils.indexOfIgnoreCase("aabaabaa", "AB", 8)); assertEquals(1, StringUtils.indexOfIgnoreCase("aab", "AB", 1)); assertEquals(5, StringUtils.indexOfIgnoreCase("aabaabaa", "", 5)); assertEquals(-1, StringUtils.indexOfIgnoreCase("ab", "AAB", 0)); assertEquals(-1, StringUtils.indexOfIgnoreCase("aab", "AAB", 1)); assertEquals(-1, StringUtils.indexOfIgnoreCase("abc", "", 9)); } @Test public void testLastIndexOf_char() { assertEquals(-1, StringUtils.lastIndexOf(null, ' ')); assertEquals(-1, StringUtils.lastIndexOf("", ' ')); assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a')); assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b')); assertEquals(5, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b')); } @Test public void testLastIndexOf_charInt() { assertEquals(-1, StringUtils.lastIndexOf(null, ' ', 0)); assertEquals(-1, StringUtils.lastIndexOf(null, ' ', -1)); assertEquals(-1, StringUtils.lastIndexOf("", ' ', 0)); assertEquals(-1, StringUtils.lastIndexOf("", ' ', -1)); assertEquals(7, StringUtils.lastIndexOf("aabaabaa", 'a', 8)); assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 8)); assertEquals(2, StringUtils.lastIndexOf("aabaabaa", 'b', 3)); assertEquals(5, StringUtils.lastIndexOf("aabaabaa", 'b', 9)); assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", 'b', -1)); assertEquals(0, StringUtils.lastIndexOf("aabaabaa", 'a', 0)); assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), 'b', 2)); //LANG-1300 addition test final int CODE_POINT = 0x2070E; StringBuilder builder = new StringBuilder(); builder.appendCodePoint(CODE_POINT); assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); builder.appendCodePoint(CODE_POINT); assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); assertEquals(0, StringUtils.lastIndexOf(builder, CODE_POINT, 1)); assertEquals(2, StringUtils.lastIndexOf(builder, CODE_POINT, 2)); builder.append("aaaaa"); assertEquals(2, StringUtils.lastIndexOf(builder, CODE_POINT, 4)); // inner branch on the supplementary character block final char[] tmp = { (char) 55361 }; builder = new StringBuilder(); builder.append(tmp); assertEquals(-1, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); builder.appendCodePoint(CODE_POINT); assertEquals(-1, StringUtils.lastIndexOf(builder, CODE_POINT, 0)); assertEquals(1, StringUtils.lastIndexOf(builder, CODE_POINT, 1 )); assertEquals(-1, StringUtils.lastIndexOf(builder.toString(), CODE_POINT, 0)); assertEquals(1, StringUtils.lastIndexOf(builder.toString(), CODE_POINT, 1)); assertEquals(StringUtils.INDEX_NOT_FOUND, StringUtils.lastIndexOf(CharBuffer.wrap("[%{.c.0rro"), -1738, 982)); } @Test public void testLastIndexOf_String() { assertEquals(-1, StringUtils.lastIndexOf(null, null)); assertEquals(-1, StringUtils.lastIndexOf("", null)); assertEquals(-1, StringUtils.lastIndexOf("", "a")); assertEquals(0, StringUtils.lastIndexOf("", "")); assertEquals(8, StringUtils.lastIndexOf("aabaabaa", "")); assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a")); assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b")); assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab")); assertEquals(4, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "ab")); } @Test public void testLastIndexOf_StringInt() { assertEquals(-1, StringUtils.lastIndexOf(null, null, 0)); assertEquals(-1, StringUtils.lastIndexOf(null, null, -1)); assertEquals(-1, StringUtils.lastIndexOf(null, "", 0)); assertEquals(-1, StringUtils.lastIndexOf(null, "", -1)); assertEquals(-1, StringUtils.lastIndexOf("", null, 0)); assertEquals(-1, StringUtils.lastIndexOf("", null, -1)); assertEquals(0, StringUtils.lastIndexOf("", "", 0)); assertEquals(-1, StringUtils.lastIndexOf("", "", -1)); assertEquals(0, StringUtils.lastIndexOf("", "", 9)); assertEquals(0, StringUtils.lastIndexOf("abc", "", 0)); assertEquals(-1, StringUtils.lastIndexOf("abc", "", -1)); assertEquals(3, StringUtils.lastIndexOf("abc", "", 9)); assertEquals(7, StringUtils.lastIndexOf("aabaabaa", "a", 8)); assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 8)); assertEquals(4, StringUtils.lastIndexOf("aabaabaa", "ab", 8)); assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 3)); assertEquals(5, StringUtils.lastIndexOf("aabaabaa", "b", 9)); assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", -1)); assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 0)); assertEquals(0, StringUtils.lastIndexOf("aabaabaa", "a", 0)); assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "a", -1)); // Test that fromIndex works correctly, i.e. cannot match after fromIndex assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 9)); assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 8)); assertEquals(7, StringUtils.lastIndexOf("12345678", "8", 7)); // 7 is last index assertEquals(-1, StringUtils.lastIndexOf("12345678", "8", 6)); assertEquals(-1, StringUtils.lastIndexOf("aabaabaa", "b", 1)); assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "b", 2)); assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 2)); assertEquals(2, StringUtils.lastIndexOf("aabaabaa", "ba", 3)); assertEquals(2, StringUtils.lastIndexOf(new StringBuilder("aabaabaa"), "b", 3)); } @Test public void testLastIndexOfAny_StringStringArray() { assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence) null)); // test both types of ... assertEquals(-1, StringUtils.lastIndexOfAny(null, (CharSequence[]) null)); // ... varargs invocation assertEquals(-1, StringUtils.lastIndexOfAny(null)); // Missing varag assertEquals(-1, StringUtils.lastIndexOfAny(null, FOOBAR_SUB_ARRAY)); assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence) null)); // test both types of ... assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, (CharSequence[]) null)); // ... varargs invocation assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR)); // Missing vararg assertEquals(3, StringUtils.lastIndexOfAny(FOOBAR, FOOBAR_SUB_ARRAY)); assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[0])); assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[0])); assertEquals(-1, StringUtils.lastIndexOfAny("", new String[0])); assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {"llll"})); assertEquals(6, StringUtils.lastIndexOfAny(FOOBAR, new String[] {""})); assertEquals(0, StringUtils.lastIndexOfAny("", new String[] {""})); assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {"a"})); assertEquals(-1, StringUtils.lastIndexOfAny("", new String[] {null})); assertEquals(-1, StringUtils.lastIndexOfAny(FOOBAR, new String[] {null})); assertEquals(-1, StringUtils.lastIndexOfAny(null, new String[] {null})); } @Test public void testLastIndexOfIgnoreCase_String() { assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "")); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "a")); assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "")); assertEquals(8, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "")); assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "a")); assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A")); assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "b")); assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B")); assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "ab")); assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB")); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("ab", "AAB")); assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aab", "AAB")); } @Test public void testLastIndexOfIgnoreCase_StringInt() { assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, 0)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, null, -1)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", 0)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase(null, "", -1)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, 0)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", null, -1)); assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 0)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("", "", -1)); assertEquals(0, StringUtils.lastIndexOfIgnoreCase("", "", 9)); assertEquals(0, StringUtils.lastIndexOfIgnoreCase("abc", "", 0)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("abc", "", -1)); assertEquals(3, StringUtils.lastIndexOfIgnoreCase("abc", "", 9)); assertEquals(7, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 8)); assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 8)); assertEquals(4, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "AB", 8)); assertEquals(2, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 3)); assertEquals(5, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 9)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", -1)); assertEquals(-1, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "B", 0)); assertEquals(0, StringUtils.lastIndexOfIgnoreCase("aabaabaa", "A", 0)); assertEquals(1, StringUtils.lastIndexOfIgnoreCase("aab", "AB", 1)); } @Test public void testLastOrdinalIndexOf() { assertEquals(-1, StringUtils.lastOrdinalIndexOf(null, "*", 42) ); assertEquals(-1, StringUtils.lastOrdinalIndexOf("*", null, 42) ); assertEquals(0, StringUtils.lastOrdinalIndexOf("", "", 42) ); assertEquals(7, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 1) ); assertEquals(6, StringUtils.lastOrdinalIndexOf("aabaabaa", "a", 2) ); assertEquals(5, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 1) ); assertEquals(2, StringUtils.lastOrdinalIndexOf("aabaabaa", "b", 2) ); assertEquals(4, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 1) ); assertEquals(1, StringUtils.lastOrdinalIndexOf("aabaabaa", "ab", 2) ); assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 1) ); assertEquals(8, StringUtils.lastOrdinalIndexOf("aabaabaa", "", 2) ); } @Test public void testOrdinalIndexOf() { assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("", "", Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MIN_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf(null, null, -1)); assertEquals(-1, StringUtils.ordinalIndexOf("", null, -1)); assertEquals(-1, StringUtils.ordinalIndexOf("", "", -1)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", -1)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", -1)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", -1)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", -1)); assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 0)); assertEquals(-1, StringUtils.ordinalIndexOf("", null, 0)); assertEquals(-1, StringUtils.ordinalIndexOf("", "", 0)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", 0)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", 0)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 0)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "", 0)); assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 1)); assertEquals(-1, StringUtils.ordinalIndexOf("", null, 1)); assertEquals(0, StringUtils.ordinalIndexOf("", "", 1)); assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "a", 1)); assertEquals(2, StringUtils.ordinalIndexOf("aabaabaa", "b", 1)); assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "ab", 1)); assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 1)); assertEquals(-1, StringUtils.ordinalIndexOf(null, null, 2)); assertEquals(-1, StringUtils.ordinalIndexOf("", null, 2)); assertEquals(0, StringUtils.ordinalIndexOf("", "", 2)); assertEquals(1, StringUtils.ordinalIndexOf("aabaabaa", "a", 2)); assertEquals(5, StringUtils.ordinalIndexOf("aabaabaa", "b", 2)); assertEquals(4, StringUtils.ordinalIndexOf("aabaabaa", "ab", 2)); assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", 2)); assertEquals(-1, StringUtils.ordinalIndexOf(null, null, Integer.MAX_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("", null, Integer.MAX_VALUE)); assertEquals(0, StringUtils.ordinalIndexOf("", "", Integer.MAX_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "a", Integer.MAX_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "b", Integer.MAX_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aabaabaa", "ab", Integer.MAX_VALUE)); assertEquals(0, StringUtils.ordinalIndexOf("aabaabaa", "", Integer.MAX_VALUE)); assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 0)); assertEquals(0, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 1)); assertEquals(1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 2)); assertEquals(2, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 3)); assertEquals(3, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 4)); assertEquals(4, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 5)); assertEquals(5, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 6)); assertEquals(6, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 7)); assertEquals(7, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 8)); assertEquals(8, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 9)); assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaaaaa", "a", 10)); // match at each possible position assertEquals(0, StringUtils.ordinalIndexOf("aaaaaa", "aa", 1)); assertEquals(1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 2)); assertEquals(2, StringUtils.ordinalIndexOf("aaaaaa", "aa", 3)); assertEquals(3, StringUtils.ordinalIndexOf("aaaaaa", "aa", 4)); assertEquals(4, StringUtils.ordinalIndexOf("aaaaaa", "aa", 5)); assertEquals(-1, StringUtils.ordinalIndexOf("aaaaaa", "aa", 6)); assertEquals(0, StringUtils.ordinalIndexOf("ababab", "aba", 1)); assertEquals(2, StringUtils.ordinalIndexOf("ababab", "aba", 2)); assertEquals(-1, StringUtils.ordinalIndexOf("ababab", "aba", 3)); assertEquals(0, StringUtils.ordinalIndexOf("abababab", "abab", 1)); assertEquals(2, StringUtils.ordinalIndexOf("abababab", "abab", 2)); assertEquals(4, StringUtils.ordinalIndexOf("abababab", "abab", 3)); assertEquals(-1, StringUtils.ordinalIndexOf("abababab", "abab", 4)); } @Test public void testLANG1193() { assertEquals(0, StringUtils.ordinalIndexOf("abc", "ab", 1)); } @Test // Non-overlapping test public void testLANG1241_1() { // 0 3 6 assertEquals(0, StringUtils.ordinalIndexOf("abaabaab", "ab", 1)); assertEquals(3, StringUtils.ordinalIndexOf("abaabaab", "ab", 2)); assertEquals(6, StringUtils.ordinalIndexOf("abaabaab", "ab", 3)); } @Test // Overlapping matching test public void testLANG1241_2() { // 0 2 4 assertEquals(0, StringUtils.ordinalIndexOf("abababa", "aba", 1)); assertEquals(2, StringUtils.ordinalIndexOf("abababa", "aba", 2)); assertEquals(4, StringUtils.ordinalIndexOf("abababa", "aba", 3)); assertEquals(0, StringUtils.ordinalIndexOf("abababab", "abab", 1)); assertEquals(2, StringUtils.ordinalIndexOf("abababab", "abab", 2)); assertEquals(4, StringUtils.ordinalIndexOf("abababab", "abab", 3)); } }