http://git-wip-us.apache.org/repos/asf/commons-text/blob/6f24aa45/src/test/java/org/apache/commons/text/StrBuilderTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/StrBuilderTest.java b/src/test/java/org/apache/commons/text/StrBuilderTest.java new file mode 100644 index 0000000..1920984 --- /dev/null +++ b/src/test/java/org/apache/commons/text/StrBuilderTest.java @@ -0,0 +1,2009 @@ +/* + * 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.text; + +import org.junit.Test; +import static org.junit.Assert.*; + +import java.io.IOException; +import java.io.Reader; +import java.io.StringReader; +import java.io.StringWriter; +import java.io.Writer; +import java.nio.CharBuffer; +import java.util.Arrays; + +import org.apache.commons.lang3.ArrayUtils; + +/** + * Unit tests for {@link StrBuilder}. + */ +public class StrBuilderTest { + + //----------------------------------------------------------------------- + @Test + public void testConstructors() { + final StrBuilder sb0 = new StrBuilder(); + assertEquals(32, sb0.capacity()); + assertEquals(0, sb0.length()); + assertEquals(0, sb0.size()); + + final StrBuilder sb1 = new StrBuilder(32); + assertEquals(32, sb1.capacity()); + assertEquals(0, sb1.length()); + assertEquals(0, sb1.size()); + + final StrBuilder sb2 = new StrBuilder(0); + assertEquals(32, sb2.capacity()); + assertEquals(0, sb2.length()); + assertEquals(0, sb2.size()); + + final StrBuilder sb3 = new StrBuilder(-1); + assertEquals(32, sb3.capacity()); + assertEquals(0, sb3.length()); + assertEquals(0, sb3.size()); + + final StrBuilder sb4 = new StrBuilder(1); + assertEquals(1, sb4.capacity()); + assertEquals(0, sb4.length()); + assertEquals(0, sb4.size()); + + final StrBuilder sb5 = new StrBuilder((String) null); + assertEquals(32, sb5.capacity()); + assertEquals(0, sb5.length()); + assertEquals(0, sb5.size()); + + final StrBuilder sb6 = new StrBuilder(""); + assertEquals(32, sb6.capacity()); + assertEquals(0, sb6.length()); + assertEquals(0, sb6.size()); + + final StrBuilder sb7 = new StrBuilder("foo"); + assertEquals(35, sb7.capacity()); + assertEquals(3, sb7.length()); + assertEquals(3, sb7.size()); + } + + //----------------------------------------------------------------------- + @Test + public void testChaining() { + final StrBuilder sb = new StrBuilder(); + assertSame(sb, sb.setNewLineText(null)); + assertSame(sb, sb.setNullText(null)); + assertSame(sb, sb.setLength(1)); + assertSame(sb, sb.setCharAt(0, 'a')); + assertSame(sb, sb.ensureCapacity(0)); + assertSame(sb, sb.minimizeCapacity()); + assertSame(sb, sb.clear()); + assertSame(sb, sb.reverse()); + assertSame(sb, sb.trim()); + } + + //----------------------------------------------------------------------- + @Test + public void testReadFromReader() throws Exception { + String s = ""; + for (int i = 0; i < 100; ++i) { + final StrBuilder sb = new StrBuilder(); + final int len = sb.readFrom(new StringReader(s)); + + assertEquals(s.length(), len); + assertEquals(s, sb.toString()); + + s += Integer.toString(i); + } + } + + @Test + public void testReadFromReaderAppendsToEnd() throws Exception { + final StrBuilder sb = new StrBuilder("Test"); + sb.readFrom(new StringReader(" 123")); + assertEquals("Test 123", sb.toString()); + } + + @Test + public void testReadFromCharBuffer() throws Exception { + String s = ""; + for (int i = 0; i < 100; ++i) { + final StrBuilder sb = new StrBuilder(); + final int len = sb.readFrom(CharBuffer.wrap(s)); + + assertEquals(s.length(), len); + assertEquals(s, sb.toString()); + + s += Integer.toString(i); + } + } + + @Test + public void testReadFromCharBufferAppendsToEnd() throws Exception { + final StrBuilder sb = new StrBuilder("Test"); + sb.readFrom(CharBuffer.wrap(" 123")); + assertEquals("Test 123", sb.toString()); + } + + @Test + public void testReadFromReadable() throws Exception { + String s = ""; + for (int i = 0; i < 100; ++i) { + final StrBuilder sb = new StrBuilder(); + final int len = sb.readFrom(new MockReadable(s)); + + assertEquals(s.length(), len); + assertEquals(s, sb.toString()); + + s += Integer.toString(i); + } + } + + @Test + public void testReadFromReadableAppendsToEnd() throws Exception { + final StrBuilder sb = new StrBuilder("Test"); + sb.readFrom(new MockReadable(" 123")); + assertEquals("Test 123", sb.toString()); + } + + private static class MockReadable implements Readable { + + private final CharBuffer src; + + public MockReadable(final String src) { + this.src = CharBuffer.wrap(src); + } + + @Override + public int read(final CharBuffer cb) throws IOException { + return src.read(cb); + } + } + + //----------------------------------------------------------------------- + @Test + public void testGetSetNewLineText() { + final StrBuilder sb = new StrBuilder(); + assertEquals(null, sb.getNewLineText()); + + sb.setNewLineText("#"); + assertEquals("#", sb.getNewLineText()); + + sb.setNewLineText(""); + assertEquals("", sb.getNewLineText()); + + sb.setNewLineText((String) null); + assertEquals(null, sb.getNewLineText()); + } + + //----------------------------------------------------------------------- + @Test + public void testGetSetNullText() { + final StrBuilder sb = new StrBuilder(); + assertEquals(null, sb.getNullText()); + + sb.setNullText("null"); + assertEquals("null", sb.getNullText()); + + sb.setNullText(""); + assertEquals(null, sb.getNullText()); + + sb.setNullText("NULL"); + assertEquals("NULL", sb.getNullText()); + + sb.setNullText((String) null); + assertEquals(null, sb.getNullText()); + } + + //----------------------------------------------------------------------- + @Test + public void testCapacityAndLength() { + final StrBuilder sb = new StrBuilder(); + assertEquals(32, sb.capacity()); + assertEquals(0, sb.length()); + assertEquals(0, sb.size()); + assertTrue(sb.isEmpty()); + + sb.minimizeCapacity(); + assertEquals(0, sb.capacity()); + assertEquals(0, sb.length()); + assertEquals(0, sb.size()); + assertTrue(sb.isEmpty()); + + sb.ensureCapacity(32); + assertTrue(sb.capacity() >= 32); + assertEquals(0, sb.length()); + assertEquals(0, sb.size()); + assertTrue(sb.isEmpty()); + + sb.append("foo"); + assertTrue(sb.capacity() >= 32); + assertEquals(3, sb.length()); + assertEquals(3, sb.size()); + assertTrue(sb.isEmpty() == false); + + sb.clear(); + assertTrue(sb.capacity() >= 32); + assertEquals(0, sb.length()); + assertEquals(0, sb.size()); + assertTrue(sb.isEmpty()); + + sb.append("123456789012345678901234567890123"); + assertTrue(sb.capacity() > 32); + assertEquals(33, sb.length()); + assertEquals(33, sb.size()); + assertTrue(sb.isEmpty() == false); + + sb.ensureCapacity(16); + assertTrue(sb.capacity() > 16); + assertEquals(33, sb.length()); + assertEquals(33, sb.size()); + assertTrue(sb.isEmpty() == false); + + sb.minimizeCapacity(); + assertEquals(33, sb.capacity()); + assertEquals(33, sb.length()); + assertEquals(33, sb.size()); + assertTrue(sb.isEmpty() == false); + + try { + sb.setLength(-1); + fail("setLength(-1) expected StringIndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + + sb.setLength(33); + assertEquals(33, sb.capacity()); + assertEquals(33, sb.length()); + assertEquals(33, sb.size()); + assertTrue(sb.isEmpty() == false); + + sb.setLength(16); + assertTrue(sb.capacity() >= 16); + assertEquals(16, sb.length()); + assertEquals(16, sb.size()); + assertEquals("1234567890123456", sb.toString()); + assertTrue(sb.isEmpty() == false); + + sb.setLength(32); + assertTrue(sb.capacity() >= 32); + assertEquals(32, sb.length()); + assertEquals(32, sb.size()); + assertEquals("1234567890123456\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", sb.toString()); + assertTrue(sb.isEmpty() == false); + + sb.setLength(0); + assertTrue(sb.capacity() >= 32); + assertEquals(0, sb.length()); + assertEquals(0, sb.size()); + assertTrue(sb.isEmpty()); + } + + //----------------------------------------------------------------------- + @Test + public void testLength() { + final StrBuilder sb = new StrBuilder(); + assertEquals(0, sb.length()); + + sb.append("Hello"); + assertEquals(5, sb.length()); + } + + @Test + public void testSetLength() { + final StrBuilder sb = new StrBuilder(); + sb.append("Hello"); + sb.setLength(2); // shorten + assertEquals("He", sb.toString()); + sb.setLength(2); // no change + assertEquals("He", sb.toString()); + sb.setLength(3); // lengthen + assertEquals("He\0", sb.toString()); + + try { + sb.setLength(-1); + fail("setLength(-1) expected StringIndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + } + + //----------------------------------------------------------------------- + @Test + public void testCapacity() { + final StrBuilder sb = new StrBuilder(); + assertEquals(sb.buffer.length, sb.capacity()); + + sb.append("HelloWorldHelloWorldHelloWorldHelloWorld"); + assertEquals(sb.buffer.length, sb.capacity()); + } + + @Test + public void testEnsureCapacity() { + final StrBuilder sb = new StrBuilder(); + sb.ensureCapacity(2); + assertTrue(sb.capacity() >= 2); + + sb.ensureCapacity(-1); + assertTrue(sb.capacity() >= 0); + + sb.append("HelloWorld"); + sb.ensureCapacity(40); + assertTrue(sb.capacity() >= 40); + } + + @Test + public void testMinimizeCapacity() { + final StrBuilder sb = new StrBuilder(); + sb.minimizeCapacity(); + assertEquals(0, sb.capacity()); + + sb.append("HelloWorld"); + sb.minimizeCapacity(); + assertEquals(10, sb.capacity()); + } + + //----------------------------------------------------------------------- + @Test + public void testSize() { + final StrBuilder sb = new StrBuilder(); + assertEquals(0, sb.size()); + + sb.append("Hello"); + assertEquals(5, sb.size()); + } + + @Test + public void testIsEmpty() { + final StrBuilder sb = new StrBuilder(); + assertTrue(sb.isEmpty()); + + sb.append("Hello"); + assertFalse(sb.isEmpty()); + + sb.clear(); + assertTrue(sb.isEmpty()); + } + + @Test + public void testClear() { + final StrBuilder sb = new StrBuilder(); + sb.append("Hello"); + sb.clear(); + assertEquals(0, sb.length()); + assertTrue(sb.buffer.length >= 5); + } + + //----------------------------------------------------------------------- + @Test + public void testCharAt() { + final StrBuilder sb = new StrBuilder(); + try { + sb.charAt(0); + fail("charAt(0) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + try { + sb.charAt(-1); + fail("charAt(-1) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + sb.append("foo"); + assertEquals('f', sb.charAt(0)); + assertEquals('o', sb.charAt(1)); + assertEquals('o', sb.charAt(2)); + try { + sb.charAt(-1); + fail("charAt(-1) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + try { + sb.charAt(3); + fail("charAt(3) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + } + + //----------------------------------------------------------------------- + @Test + public void testSetCharAt() { + final StrBuilder sb = new StrBuilder(); + try { + sb.setCharAt(0, 'f'); + fail("setCharAt(0,) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + try { + sb.setCharAt(-1, 'f'); + fail("setCharAt(-1,) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + sb.append("foo"); + sb.setCharAt(0, 'b'); + sb.setCharAt(1, 'a'); + sb.setCharAt(2, 'r'); + try { + sb.setCharAt(3, '!'); + fail("setCharAt(3,) expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) { + // expected + } + assertEquals("bar", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testDeleteCharAt() { + final StrBuilder sb = new StrBuilder("abc"); + sb.deleteCharAt(0); + assertEquals("bc", sb.toString()); + + try { + sb.deleteCharAt(1000); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + } + + //----------------------------------------------------------------------- + @Test + public void testToCharArray() { + final StrBuilder sb = new StrBuilder(); + assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, sb.toCharArray()); + + char[] a = sb.toCharArray(); + assertNotNull("toCharArray() result is null", a); + assertEquals("toCharArray() result is too large", 0, a.length); + + sb.append("junit"); + a = sb.toCharArray(); + assertEquals("toCharArray() result incorrect length", 5, a.length); + assertTrue("toCharArray() result does not match", Arrays.equals("junit".toCharArray(), a)); + } + + @Test + public void testToCharArrayIntInt() { + final StrBuilder sb = new StrBuilder(); + assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, sb.toCharArray(0, 0)); + + sb.append("junit"); + char[] a = sb.toCharArray(0, 20); // too large test + assertEquals("toCharArray(int,int) result incorrect length", 5, a.length); + assertTrue("toCharArray(int,int) result does not match", Arrays.equals("junit".toCharArray(), a)); + + a = sb.toCharArray(0, 4); + assertEquals("toCharArray(int,int) result incorrect length", 4, a.length); + assertTrue("toCharArray(int,int) result does not match", Arrays.equals("juni".toCharArray(), a)); + + a = sb.toCharArray(0, 4); + assertEquals("toCharArray(int,int) result incorrect length", 4, a.length); + assertTrue("toCharArray(int,int) result does not match", Arrays.equals("juni".toCharArray(), a)); + + a = sb.toCharArray(0, 1); + assertNotNull("toCharArray(int,int) result is null", a); + + try { + sb.toCharArray(-1, 5); + fail("no string index out of bound on -1"); + } catch (final IndexOutOfBoundsException e) { + } + + try { + sb.toCharArray(6, 5); + fail("no string index out of bound on -1"); + } catch (final IndexOutOfBoundsException e) { + } + } + + @Test + public void testGetChars ( ) { + final StrBuilder sb = new StrBuilder(); + + char[] input = new char[10]; + char[] a = sb.getChars(input); + assertSame (input, a); + assertTrue(Arrays.equals(new char[10], a)); + + sb.append("junit"); + a = sb.getChars(input); + assertSame(input, a); + assertTrue(Arrays.equals(new char[] {'j','u','n','i','t',0,0,0,0,0},a)); + + a = sb.getChars(null); + assertNotSame(input,a); + assertEquals(5,a.length); + assertTrue(Arrays.equals("junit".toCharArray(),a)); + + input = new char[5]; + a = sb.getChars(input); + assertSame(input, a); + + input = new char[4]; + a = sb.getChars(input); + assertNotSame(input, a); + } + + @Test + public void testGetCharsIntIntCharArrayInt( ) { + final StrBuilder sb = new StrBuilder(); + + sb.append("junit"); + char[] a = new char[5]; + sb.getChars(0,5,a,0); + assertTrue(Arrays.equals(new char[] {'j','u','n','i','t'},a)); + + a = new char[5]; + sb.getChars(0,2,a,3); + assertTrue(Arrays.equals(new char[] {0,0,0,'j','u'},a)); + + try { + sb.getChars(-1,0,a,0); + fail("no exception"); + } + catch (final IndexOutOfBoundsException e) { + } + + try { + sb.getChars(0,-1,a,0); + fail("no exception"); + } + catch (final IndexOutOfBoundsException e) { + } + + try { + sb.getChars(0,20,a,0); + fail("no exception"); + } + catch (final IndexOutOfBoundsException e) { + } + + try { + sb.getChars(4,2,a,0); + fail("no exception"); + } + catch (final IndexOutOfBoundsException e) { + } + } + + //----------------------------------------------------------------------- + @Test + public void testDeleteIntInt() { + StrBuilder sb = new StrBuilder("abc"); + sb.delete(0, 1); + assertEquals("bc", sb.toString()); + sb.delete(1, 2); + assertEquals("b", sb.toString()); + sb.delete(0, 1); + assertEquals("", sb.toString()); + sb.delete(0, 1000); + assertEquals("", sb.toString()); + + try { + sb.delete(1, 2); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + try { + sb.delete(-1, 1); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + + sb = new StrBuilder("anything"); + try { + sb.delete(2, 1); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + } + + //----------------------------------------------------------------------- + @Test + public void testDeleteAll_char() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.deleteAll('X'); + assertEquals("abcbccba", sb.toString()); + sb.deleteAll('a'); + assertEquals("bcbccb", sb.toString()); + sb.deleteAll('c'); + assertEquals("bbb", sb.toString()); + sb.deleteAll('b'); + assertEquals("", sb.toString()); + + sb = new StrBuilder(""); + sb.deleteAll('b'); + assertEquals("", sb.toString()); + } + + @Test + public void testDeleteFirst_char() { + StrBuilder sb = new StrBuilder("abcba"); + sb.deleteFirst('X'); + assertEquals("abcba", sb.toString()); + sb.deleteFirst('a'); + assertEquals("bcba", sb.toString()); + sb.deleteFirst('c'); + assertEquals("bba", sb.toString()); + sb.deleteFirst('b'); + assertEquals("ba", sb.toString()); + + sb = new StrBuilder(""); + sb.deleteFirst('b'); + assertEquals("", sb.toString()); + } + + // ----------------------------------------------------------------------- + @Test + public void testDeleteAll_String() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.deleteAll((String) null); + assertEquals("abcbccba", sb.toString()); + sb.deleteAll(""); + assertEquals("abcbccba", sb.toString()); + + sb.deleteAll("X"); + assertEquals("abcbccba", sb.toString()); + sb.deleteAll("a"); + assertEquals("bcbccb", sb.toString()); + sb.deleteAll("c"); + assertEquals("bbb", sb.toString()); + sb.deleteAll("b"); + assertEquals("", sb.toString()); + + sb = new StrBuilder("abcbccba"); + sb.deleteAll("bc"); + assertEquals("acba", sb.toString()); + + sb = new StrBuilder(""); + sb.deleteAll("bc"); + assertEquals("", sb.toString()); + } + + @Test + public void testDeleteFirst_String() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.deleteFirst((String) null); + assertEquals("abcbccba", sb.toString()); + sb.deleteFirst(""); + assertEquals("abcbccba", sb.toString()); + + sb.deleteFirst("X"); + assertEquals("abcbccba", sb.toString()); + sb.deleteFirst("a"); + assertEquals("bcbccba", sb.toString()); + sb.deleteFirst("c"); + assertEquals("bbccba", sb.toString()); + sb.deleteFirst("b"); + assertEquals("bccba", sb.toString()); + + sb = new StrBuilder("abcbccba"); + sb.deleteFirst("bc"); + assertEquals("abccba", sb.toString()); + + sb = new StrBuilder(""); + sb.deleteFirst("bc"); + assertEquals("", sb.toString()); + } + + // ----------------------------------------------------------------------- + @Test + public void testDeleteAll_StrMatcher() { + StrBuilder sb = new StrBuilder("A0xA1A2yA3"); + sb.deleteAll((StrMatcher) null); + assertEquals("A0xA1A2yA3", sb.toString()); + sb.deleteAll(A_NUMBER_MATCHER); + assertEquals("xy", sb.toString()); + + sb = new StrBuilder("Ax1"); + sb.deleteAll(A_NUMBER_MATCHER); + assertEquals("Ax1", sb.toString()); + + sb = new StrBuilder(""); + sb.deleteAll(A_NUMBER_MATCHER); + assertEquals("", sb.toString()); + } + + @Test + public void testDeleteFirst_StrMatcher() { + StrBuilder sb = new StrBuilder("A0xA1A2yA3"); + sb.deleteFirst((StrMatcher) null); + assertEquals("A0xA1A2yA3", sb.toString()); + sb.deleteFirst(A_NUMBER_MATCHER); + assertEquals("xA1A2yA3", sb.toString()); + + sb = new StrBuilder("Ax1"); + sb.deleteFirst(A_NUMBER_MATCHER); + assertEquals("Ax1", sb.toString()); + + sb = new StrBuilder(""); + sb.deleteFirst(A_NUMBER_MATCHER); + assertEquals("", sb.toString()); + } + + // ----------------------------------------------------------------------- + @Test + public void testReplace_int_int_String() { + StrBuilder sb = new StrBuilder("abc"); + sb.replace(0, 1, "d"); + assertEquals("dbc", sb.toString()); + sb.replace(0, 1, "aaa"); + assertEquals("aaabc", sb.toString()); + sb.replace(0, 3, ""); + assertEquals("bc", sb.toString()); + sb.replace(1, 2, (String) null); + assertEquals("b", sb.toString()); + sb.replace(1, 1000, "text"); + assertEquals("btext", sb.toString()); + sb.replace(0, 1000, "text"); + assertEquals("text", sb.toString()); + + sb = new StrBuilder("atext"); + sb.replace(1, 1, "ny"); + assertEquals("anytext", sb.toString()); + try { + sb.replace(2, 1, "anything"); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + + sb = new StrBuilder(); + try { + sb.replace(1, 2, "anything"); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + try { + sb.replace(-1, 1, "anything"); + fail("Expected IndexOutOfBoundsException"); + } catch (final IndexOutOfBoundsException e) {} + } + + //----------------------------------------------------------------------- + @Test + public void testReplaceAll_char_char() { + final StrBuilder sb = new StrBuilder("abcbccba"); + sb.replaceAll('x', 'y'); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll('a', 'd'); + assertEquals("dbcbccbd", sb.toString()); + sb.replaceAll('b', 'e'); + assertEquals("dececced", sb.toString()); + sb.replaceAll('c', 'f'); + assertEquals("defeffed", sb.toString()); + sb.replaceAll('d', 'd'); + assertEquals("defeffed", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testReplaceFirst_char_char() { + final StrBuilder sb = new StrBuilder("abcbccba"); + sb.replaceFirst('x', 'y'); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst('a', 'd'); + assertEquals("dbcbccba", sb.toString()); + sb.replaceFirst('b', 'e'); + assertEquals("decbccba", sb.toString()); + sb.replaceFirst('c', 'f'); + assertEquals("defbccba", sb.toString()); + sb.replaceFirst('d', 'd'); + assertEquals("defbccba", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testReplaceAll_String_String() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.replaceAll((String) null, null); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll((String) null, "anything"); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll("", null); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll("", "anything"); + assertEquals("abcbccba", sb.toString()); + + sb.replaceAll("x", "y"); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll("a", "d"); + assertEquals("dbcbccbd", sb.toString()); + sb.replaceAll("d", null); + assertEquals("bcbccb", sb.toString()); + sb.replaceAll("cb", "-"); + assertEquals("b-c-", sb.toString()); + + sb = new StrBuilder("abcba"); + sb.replaceAll("b", "xbx"); + assertEquals("axbxcxbxa", sb.toString()); + + sb = new StrBuilder("bb"); + sb.replaceAll("b", "xbx"); + assertEquals("xbxxbx", sb.toString()); + } + + @Test + public void testReplaceFirst_String_String() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.replaceFirst((String) null, null); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst((String) null, "anything"); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst("", null); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst("", "anything"); + assertEquals("abcbccba", sb.toString()); + + sb.replaceFirst("x", "y"); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst("a", "d"); + assertEquals("dbcbccba", sb.toString()); + sb.replaceFirst("d", null); + assertEquals("bcbccba", sb.toString()); + sb.replaceFirst("cb", "-"); + assertEquals("b-ccba", sb.toString()); + + sb = new StrBuilder("abcba"); + sb.replaceFirst("b", "xbx"); + assertEquals("axbxcba", sb.toString()); + + sb = new StrBuilder("bb"); + sb.replaceFirst("b", "xbx"); + assertEquals("xbxb", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testReplaceAll_StrMatcher_String() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.replaceAll((StrMatcher) null, null); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll((StrMatcher) null, "anything"); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll(StrMatcher.noneMatcher(), null); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll(StrMatcher.noneMatcher(), "anything"); + assertEquals("abcbccba", sb.toString()); + + sb.replaceAll(StrMatcher.charMatcher('x'), "y"); + assertEquals("abcbccba", sb.toString()); + sb.replaceAll(StrMatcher.charMatcher('a'), "d"); + assertEquals("dbcbccbd", sb.toString()); + sb.replaceAll(StrMatcher.charMatcher('d'), null); + assertEquals("bcbccb", sb.toString()); + sb.replaceAll(StrMatcher.stringMatcher("cb"), "-"); + assertEquals("b-c-", sb.toString()); + + sb = new StrBuilder("abcba"); + sb.replaceAll(StrMatcher.charMatcher('b'), "xbx"); + assertEquals("axbxcxbxa", sb.toString()); + + sb = new StrBuilder("bb"); + sb.replaceAll(StrMatcher.charMatcher('b'), "xbx"); + assertEquals("xbxxbx", sb.toString()); + + sb = new StrBuilder("A1-A2A3-A4"); + sb.replaceAll(A_NUMBER_MATCHER, "***"); + assertEquals("***-******-***", sb.toString()); + + sb = new StrBuilder("Dear X, hello X."); + sb.replaceAll(StrMatcher.stringMatcher("X"), "012345678901234567"); + assertEquals("Dear 012345678901234567, hello 012345678901234567.", sb.toString()); + } + + @Test + public void testReplaceFirst_StrMatcher_String() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.replaceFirst((StrMatcher) null, null); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst((StrMatcher) null, "anything"); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst(StrMatcher.noneMatcher(), null); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst(StrMatcher.noneMatcher(), "anything"); + assertEquals("abcbccba", sb.toString()); + + sb.replaceFirst(StrMatcher.charMatcher('x'), "y"); + assertEquals("abcbccba", sb.toString()); + sb.replaceFirst(StrMatcher.charMatcher('a'), "d"); + assertEquals("dbcbccba", sb.toString()); + sb.replaceFirst(StrMatcher.charMatcher('d'), null); + assertEquals("bcbccba", sb.toString()); + sb.replaceFirst(StrMatcher.stringMatcher("cb"), "-"); + assertEquals("b-ccba", sb.toString()); + + sb = new StrBuilder("abcba"); + sb.replaceFirst(StrMatcher.charMatcher('b'), "xbx"); + assertEquals("axbxcba", sb.toString()); + + sb = new StrBuilder("bb"); + sb.replaceFirst(StrMatcher.charMatcher('b'), "xbx"); + assertEquals("xbxb", sb.toString()); + + sb = new StrBuilder("A1-A2A3-A4"); + sb.replaceFirst(A_NUMBER_MATCHER, "***"); + assertEquals("***-A2A3-A4", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testReplace_StrMatcher_String_int_int_int_VaryMatcher() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.replace((StrMatcher) null, "x", 0, sb.length(), -1); + assertEquals("abcbccba", sb.toString()); + + sb.replace(StrMatcher.charMatcher('a'), "x", 0, sb.length(), -1); + assertEquals("xbcbccbx", sb.toString()); + + sb.replace(StrMatcher.stringMatcher("cb"), "x", 0, sb.length(), -1); + assertEquals("xbxcxx", sb.toString()); + + sb = new StrBuilder("A1-A2A3-A4"); + sb.replace(A_NUMBER_MATCHER, "***", 0, sb.length(), -1); + assertEquals("***-******-***", sb.toString()); + + sb = new StrBuilder(); + sb.replace(A_NUMBER_MATCHER, "***", 0, sb.length(), -1); + assertEquals("", sb.toString()); + } + + @Test + public void testReplace_StrMatcher_String_int_int_int_VaryReplace() { + StrBuilder sb = new StrBuilder("abcbccba"); + sb.replace(StrMatcher.stringMatcher("cb"), "cb", 0, sb.length(), -1); + assertEquals("abcbccba", sb.toString()); + + sb = new StrBuilder("abcbccba"); + sb.replace(StrMatcher.stringMatcher("cb"), "-", 0, sb.length(), -1); + assertEquals("ab-c-a", sb.toString()); + + sb = new StrBuilder("abcbccba"); + sb.replace(StrMatcher.stringMatcher("cb"), "+++", 0, sb.length(), -1); + assertEquals("ab+++c+++a", sb.toString()); + + sb = new StrBuilder("abcbccba"); + sb.replace(StrMatcher.stringMatcher("cb"), "", 0, sb.length(), -1); + assertEquals("abca", sb.toString()); + + sb = new StrBuilder("abcbccba"); + sb.replace(StrMatcher.stringMatcher("cb"), null, 0, sb.length(), -1); + assertEquals("abca", sb.toString()); + } + + @Test + public void testReplace_StrMatcher_String_int_int_int_VaryStartIndex() { + StrBuilder sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, sb.length(), -1); + assertEquals("-x--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 1, sb.length(), -1); + assertEquals("aax--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 2, sb.length(), -1); + assertEquals("aax--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 3, sb.length(), -1); + assertEquals("aax--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 4, sb.length(), -1); + assertEquals("aaxa-ay-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 5, sb.length(), -1); + assertEquals("aaxaa-y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 6, sb.length(), -1); + assertEquals("aaxaaaay-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 7, sb.length(), -1); + assertEquals("aaxaaaay-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 8, sb.length(), -1); + assertEquals("aaxaaaay-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 9, sb.length(), -1); + assertEquals("aaxaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 10, sb.length(), -1); + assertEquals("aaxaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + try { + sb.replace(StrMatcher.stringMatcher("aa"), "-", 11, sb.length(), -1); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + assertEquals("aaxaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + try { + sb.replace(StrMatcher.stringMatcher("aa"), "-", -1, sb.length(), -1); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + assertEquals("aaxaaaayaa", sb.toString()); + } + + @Test + public void testReplace_StrMatcher_String_int_int_int_VaryEndIndex() { + StrBuilder sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 0, -1); + assertEquals("aaxaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 2, -1); + assertEquals("-xaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 3, -1); + assertEquals("-xaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 4, -1); + assertEquals("-xaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 5, -1); + assertEquals("-x-aayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 6, -1); + assertEquals("-x-aayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 7, -1); + assertEquals("-x--yaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 8, -1); + assertEquals("-x--yaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 9, -1); + assertEquals("-x--yaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, -1); + assertEquals("-x--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 1000, -1); + assertEquals("-x--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + try { + sb.replace(StrMatcher.stringMatcher("aa"), "-", 2, 1, -1); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + assertEquals("aaxaaaayaa", sb.toString()); + } + + @Test + public void testReplace_StrMatcher_String_int_int_int_VaryCount() { + StrBuilder sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, -1); + assertEquals("-x--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 0); + assertEquals("aaxaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 1); + assertEquals("-xaaaayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 2); + assertEquals("-x-aayaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 3); + assertEquals("-x--yaa", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 4); + assertEquals("-x--y-", sb.toString()); + + sb = new StrBuilder("aaxaaaayaa"); + sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 5); + assertEquals("-x--y-", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testReverse() { + final StrBuilder sb = new StrBuilder(); + assertEquals("", sb.reverse().toString()); + + sb.clear().append(true); + assertEquals("eurt", sb.reverse().toString()); + assertEquals("true", sb.reverse().toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testTrim() { + final StrBuilder sb = new StrBuilder(); + assertEquals("", sb.reverse().toString()); + + sb.clear().append(" \u0000 "); + assertEquals("", sb.trim().toString()); + + sb.clear().append(" \u0000 a b c"); + assertEquals("a b c", sb.trim().toString()); + + sb.clear().append("a b c \u0000 "); + assertEquals("a b c", sb.trim().toString()); + + sb.clear().append(" \u0000 a b c \u0000 "); + assertEquals("a b c", sb.trim().toString()); + + sb.clear().append("a b c"); + assertEquals("a b c", sb.trim().toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testStartsWith() { + final StrBuilder sb = new StrBuilder(); + assertFalse(sb.startsWith("a")); + assertFalse(sb.startsWith(null)); + assertTrue(sb.startsWith("")); + sb.append("abc"); + assertTrue(sb.startsWith("a")); + assertTrue(sb.startsWith("ab")); + assertTrue(sb.startsWith("abc")); + assertFalse(sb.startsWith("cba")); + } + + @Test + public void testEndsWith() { + final StrBuilder sb = new StrBuilder(); + assertFalse(sb.endsWith("a")); + assertFalse(sb.endsWith("c")); + assertTrue(sb.endsWith("")); + assertFalse(sb.endsWith(null)); + sb.append("abc"); + assertTrue(sb.endsWith("c")); + assertTrue(sb.endsWith("bc")); + assertTrue(sb.endsWith("abc")); + assertFalse(sb.endsWith("cba")); + assertFalse(sb.endsWith("abcd")); + assertFalse(sb.endsWith(" abc")); + assertFalse(sb.endsWith("abc ")); + } + + //----------------------------------------------------------------------- + @Test + public void testSubSequenceIntInt() { + final StrBuilder sb = new StrBuilder ("hello goodbye"); + // Start index is negative + try { + sb.subSequence(-1, 5); + fail(); + } catch (final IndexOutOfBoundsException e) {} + + // End index is negative + try { + sb.subSequence(2, -1); + fail(); + } catch (final IndexOutOfBoundsException e) {} + + // End index greater than length() + try { + sb.subSequence(2, sb.length() + 1); + fail(); + } catch (final IndexOutOfBoundsException e) {} + + // Start index greater then end index + try { + sb.subSequence(3, 2); + fail(); + } catch (final IndexOutOfBoundsException e) {} + + // Normal cases + assertEquals ("hello", sb.subSequence(0, 5)); + assertEquals ("hello goodbye".subSequence(0, 6), sb.subSequence(0, 6)); + assertEquals ("goodbye", sb.subSequence(6, 13)); + assertEquals ("hello goodbye".subSequence(6,13), sb.subSequence(6, 13)); + } + + @Test + public void testSubstringInt() { + final StrBuilder sb = new StrBuilder ("hello goodbye"); + assertEquals ("goodbye", sb.substring(6)); + assertEquals ("hello goodbye".substring(6), sb.substring(6)); + assertEquals ("hello goodbye", sb.substring(0)); + assertEquals ("hello goodbye".substring(0), sb.substring(0)); + try { + sb.substring(-1); + fail (); + } catch (final IndexOutOfBoundsException e) {} + + try { + sb.substring(15); + fail (); + } catch (final IndexOutOfBoundsException e) {} + + } + + @Test + public void testSubstringIntInt() { + final StrBuilder sb = new StrBuilder ("hello goodbye"); + assertEquals ("hello", sb.substring(0, 5)); + assertEquals ("hello goodbye".substring(0, 6), sb.substring(0, 6)); + + assertEquals ("goodbye", sb.substring(6, 13)); + assertEquals ("hello goodbye".substring(6,13), sb.substring(6, 13)); + + assertEquals ("goodbye", sb.substring(6, 20)); + + try { + sb.substring(-1, 5); + fail(); + } catch (final IndexOutOfBoundsException e) {} + + try { + sb.substring(15, 20); + fail(); + } catch (final IndexOutOfBoundsException e) {} + } + + // ----------------------------------------------------------------------- + @Test + public void testMidString() { + final StrBuilder sb = new StrBuilder("hello goodbye hello"); + assertEquals("goodbye", sb.midString(6, 7)); + assertEquals("hello", sb.midString(0, 5)); + assertEquals("hello", sb.midString(-5, 5)); + assertEquals("", sb.midString(0, -1)); + assertEquals("", sb.midString(20, 2)); + assertEquals("hello", sb.midString(14, 22)); + } + + @Test + public void testRightString() { + final StrBuilder sb = new StrBuilder("left right"); + assertEquals("right", sb.rightString(5)); + assertEquals("", sb.rightString(0)); + assertEquals("", sb.rightString(-5)); + assertEquals("left right", sb.rightString(15)); + } + + @Test + public void testLeftString() { + final StrBuilder sb = new StrBuilder("left right"); + assertEquals("left", sb.leftString(4)); + assertEquals("", sb.leftString(0)); + assertEquals("", sb.leftString(-5)); + assertEquals("left right", sb.leftString(15)); + } + + // ----------------------------------------------------------------------- + @Test + public void testContains_char() { + final StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz"); + assertTrue(sb.contains('a')); + assertTrue(sb.contains('o')); + assertTrue(sb.contains('z')); + assertFalse(sb.contains('1')); + } + + @Test + public void testContains_String() { + final StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz"); + assertTrue(sb.contains("a")); + assertTrue(sb.contains("pq")); + assertTrue(sb.contains("z")); + assertFalse(sb.contains("zyx")); + assertFalse(sb.contains((String) null)); + } + + @Test + public void testContains_StrMatcher() { + StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz"); + assertTrue(sb.contains(StrMatcher.charMatcher('a'))); + assertTrue(sb.contains(StrMatcher.stringMatcher("pq"))); + assertTrue(sb.contains(StrMatcher.charMatcher('z'))); + assertFalse(sb.contains(StrMatcher.stringMatcher("zy"))); + assertFalse(sb.contains((StrMatcher) null)); + + sb = new StrBuilder(); + assertFalse(sb.contains(A_NUMBER_MATCHER)); + sb.append("B A1 C"); + assertTrue(sb.contains(A_NUMBER_MATCHER)); + } + + // ----------------------------------------------------------------------- + @Test + public void testIndexOf_char() { + final StrBuilder sb = new StrBuilder("abab"); + assertEquals(0, sb.indexOf('a')); + + // should work like String#indexOf + assertEquals("abab".indexOf('a'), sb.indexOf('a')); + + assertEquals(1, sb.indexOf('b')); + assertEquals("abab".indexOf('b'), sb.indexOf('b')); + + assertEquals(-1, sb.indexOf('z')); + } + + @Test + public void testIndexOf_char_int() { + StrBuilder sb = new StrBuilder("abab"); + assertEquals(0, sb.indexOf('a', -1)); + assertEquals(0, sb.indexOf('a', 0)); + assertEquals(2, sb.indexOf('a', 1)); + assertEquals(-1, sb.indexOf('a', 4)); + assertEquals(-1, sb.indexOf('a', 5)); + + // should work like String#indexOf + assertEquals("abab".indexOf('a', 1), sb.indexOf('a', 1)); + + assertEquals(3, sb.indexOf('b', 2)); + assertEquals("abab".indexOf('b', 2), sb.indexOf('b', 2)); + + assertEquals(-1, sb.indexOf('z', 2)); + + sb = new StrBuilder("xyzabc"); + assertEquals(2, sb.indexOf('z', 0)); + assertEquals(-1, sb.indexOf('z', 3)); + } + + @Test + public void testLastIndexOf_char() { + final StrBuilder sb = new StrBuilder("abab"); + + assertEquals (2, sb.lastIndexOf('a')); + //should work like String#lastIndexOf + assertEquals ("abab".lastIndexOf('a'), sb.lastIndexOf('a')); + + assertEquals(3, sb.lastIndexOf('b')); + assertEquals ("abab".lastIndexOf('b'), sb.lastIndexOf('b')); + + assertEquals (-1, sb.lastIndexOf('z')); + } + + @Test + public void testLastIndexOf_char_int() { + StrBuilder sb = new StrBuilder("abab"); + assertEquals(-1, sb.lastIndexOf('a', -1)); + assertEquals(0, sb.lastIndexOf('a', 0)); + assertEquals(0, sb.lastIndexOf('a', 1)); + + // should work like String#lastIndexOf + assertEquals("abab".lastIndexOf('a', 1), sb.lastIndexOf('a', 1)); + + assertEquals(1, sb.lastIndexOf('b', 2)); + assertEquals("abab".lastIndexOf('b', 2), sb.lastIndexOf('b', 2)); + + assertEquals(-1, sb.lastIndexOf('z', 2)); + + sb = new StrBuilder("xyzabc"); + assertEquals(2, sb.lastIndexOf('z', sb.length())); + assertEquals(-1, sb.lastIndexOf('z', 1)); + } + + // ----------------------------------------------------------------------- + @Test + public void testIndexOf_String() { + final StrBuilder sb = new StrBuilder("abab"); + + assertEquals(0, sb.indexOf("a")); + //should work like String#indexOf + assertEquals("abab".indexOf("a"), sb.indexOf("a")); + + assertEquals(0, sb.indexOf("ab")); + //should work like String#indexOf + assertEquals("abab".indexOf("ab"), sb.indexOf("ab")); + + assertEquals(1, sb.indexOf("b")); + assertEquals("abab".indexOf("b"), sb.indexOf("b")); + + assertEquals(1, sb.indexOf("ba")); + assertEquals("abab".indexOf("ba"), sb.indexOf("ba")); + + assertEquals(-1, sb.indexOf("z")); + + assertEquals(-1, sb.indexOf((String) null)); + } + + @Test + public void testIndexOf_String_int() { + StrBuilder sb = new StrBuilder("abab"); + assertEquals(0, sb.indexOf("a", -1)); + assertEquals(0, sb.indexOf("a", 0)); + assertEquals(2, sb.indexOf("a", 1)); + assertEquals(2, sb.indexOf("a", 2)); + assertEquals(-1, sb.indexOf("a", 3)); + assertEquals(-1, sb.indexOf("a", 4)); + assertEquals(-1, sb.indexOf("a", 5)); + + assertEquals(-1, sb.indexOf("abcdef", 0)); + assertEquals(0, sb.indexOf("", 0)); + assertEquals(1, sb.indexOf("", 1)); + + //should work like String#indexOf + assertEquals ("abab".indexOf("a", 1), sb.indexOf("a", 1)); + + assertEquals(2, sb.indexOf("ab", 1)); + //should work like String#indexOf + assertEquals("abab".indexOf("ab", 1), sb.indexOf("ab", 1)); + + assertEquals(3, sb.indexOf("b", 2)); + assertEquals("abab".indexOf("b", 2), sb.indexOf("b", 2)); + + assertEquals(1, sb.indexOf("ba", 1)); + assertEquals("abab".indexOf("ba", 2), sb.indexOf("ba", 2)); + + assertEquals(-1, sb.indexOf("z", 2)); + + sb = new StrBuilder("xyzabc"); + assertEquals(2, sb.indexOf("za", 0)); + assertEquals(-1, sb.indexOf("za", 3)); + + assertEquals(-1, sb.indexOf((String) null, 2)); + } + + @Test + public void testLastIndexOf_String() { + final StrBuilder sb = new StrBuilder("abab"); + + assertEquals(2, sb.lastIndexOf("a")); + //should work like String#lastIndexOf + assertEquals("abab".lastIndexOf("a"), sb.lastIndexOf("a")); + + assertEquals(2, sb.lastIndexOf("ab")); + //should work like String#lastIndexOf + assertEquals("abab".lastIndexOf("ab"), sb.lastIndexOf("ab")); + + assertEquals(3, sb.lastIndexOf("b")); + assertEquals("abab".lastIndexOf("b"), sb.lastIndexOf("b")); + + assertEquals(1, sb.lastIndexOf("ba")); + assertEquals("abab".lastIndexOf("ba"), sb.lastIndexOf("ba")); + + assertEquals(-1, sb.lastIndexOf("z")); + + assertEquals(-1, sb.lastIndexOf((String) null)); + } + + @Test + public void testLastIndexOf_String_int() { + StrBuilder sb = new StrBuilder("abab"); + assertEquals(-1, sb.lastIndexOf("a", -1)); + assertEquals(0, sb.lastIndexOf("a", 0)); + assertEquals(0, sb.lastIndexOf("a", 1)); + assertEquals(2, sb.lastIndexOf("a", 2)); + assertEquals(2, sb.lastIndexOf("a", 3)); + assertEquals(2, sb.lastIndexOf("a", 4)); + assertEquals(2, sb.lastIndexOf("a", 5)); + + assertEquals(-1, sb.lastIndexOf("abcdef", 3)); + assertEquals("abab".lastIndexOf("", 3), sb.lastIndexOf("", 3)); + assertEquals("abab".lastIndexOf("", 1), sb.lastIndexOf("", 1)); + + //should work like String#lastIndexOf + assertEquals("abab".lastIndexOf("a", 1), sb.lastIndexOf("a", 1)); + + assertEquals(0, sb.lastIndexOf("ab", 1)); + //should work like String#lastIndexOf + assertEquals("abab".lastIndexOf("ab", 1), sb.lastIndexOf("ab", 1)); + + assertEquals(1, sb.lastIndexOf("b", 2)); + assertEquals("abab".lastIndexOf("b", 2), sb.lastIndexOf("b", 2)); + + assertEquals(1, sb.lastIndexOf("ba", 2)); + assertEquals("abab".lastIndexOf("ba", 2), sb.lastIndexOf("ba", 2)); + + assertEquals(-1, sb.lastIndexOf("z", 2)); + + sb = new StrBuilder("xyzabc"); + assertEquals(2, sb.lastIndexOf("za", sb.length())); + assertEquals(-1, sb.lastIndexOf("za", 1)); + + assertEquals(-1, sb.lastIndexOf((String) null, 2)); + } + + // ----------------------------------------------------------------------- + @Test + public void testIndexOf_StrMatcher() { + final StrBuilder sb = new StrBuilder(); + assertEquals(-1, sb.indexOf((StrMatcher) null)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'))); + + sb.append("ab bd"); + assertEquals(0, sb.indexOf(StrMatcher.charMatcher('a'))); + assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'))); + assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher())); + assertEquals(4, sb.indexOf(StrMatcher.charMatcher('d'))); + assertEquals(-1, sb.indexOf(StrMatcher.noneMatcher())); + assertEquals(-1, sb.indexOf((StrMatcher) null)); + + sb.append(" A1 junction"); + assertEquals(6, sb.indexOf(A_NUMBER_MATCHER)); + } + + @Test + public void testIndexOf_StrMatcher_int() { + final StrBuilder sb = new StrBuilder(); + assertEquals(-1, sb.indexOf((StrMatcher) null, 2)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 2)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 0)); + + sb.append("ab bd"); + assertEquals(0, sb.indexOf(StrMatcher.charMatcher('a'), -2)); + assertEquals(0, sb.indexOf(StrMatcher.charMatcher('a'), 0)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 2)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 20)); + + assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'), -1)); + assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'), 0)); + assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'), 1)); + assertEquals(3, sb.indexOf(StrMatcher.charMatcher('b'), 2)); + assertEquals(3, sb.indexOf(StrMatcher.charMatcher('b'), 3)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('b'), 4)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('b'), 5)); + assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('b'), 6)); + + assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher(), -2)); + assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher(), 0)); + assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher(), 2)); + assertEquals(-1, sb.indexOf(StrMatcher.spaceMatcher(), 4)); + assertEquals(-1, sb.indexOf(StrMatcher.spaceMatcher(), 20)); + + assertEquals(-1, sb.indexOf(StrMatcher.noneMatcher(), 0)); + assertEquals(-1, sb.indexOf((StrMatcher) null, 0)); + + sb.append(" A1 junction with A2"); + assertEquals(6, sb.indexOf(A_NUMBER_MATCHER, 5)); + assertEquals(6, sb.indexOf(A_NUMBER_MATCHER, 6)); + assertEquals(23, sb.indexOf(A_NUMBER_MATCHER, 7)); + assertEquals(23, sb.indexOf(A_NUMBER_MATCHER, 22)); + assertEquals(23, sb.indexOf(A_NUMBER_MATCHER, 23)); + assertEquals(-1, sb.indexOf(A_NUMBER_MATCHER, 24)); + } + + @Test + public void testLastIndexOf_StrMatcher() { + final StrBuilder sb = new StrBuilder(); + assertEquals(-1, sb.lastIndexOf((StrMatcher) null)); + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'))); + + sb.append("ab bd"); + assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'))); + assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'))); + assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher())); + assertEquals(4, sb.lastIndexOf(StrMatcher.charMatcher('d'))); + assertEquals(-1, sb.lastIndexOf(StrMatcher.noneMatcher())); + assertEquals(-1, sb.lastIndexOf((StrMatcher) null)); + + sb.append(" A1 junction"); + assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER)); + } + + @Test + public void testLastIndexOf_StrMatcher_int() { + final StrBuilder sb = new StrBuilder(); + assertEquals(-1, sb.lastIndexOf((StrMatcher) null, 2)); + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), 2)); + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), 0)); + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), -1)); + + sb.append("ab bd"); + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), -2)); + assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'), 0)); + assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'), 2)); + assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'), 20)); + + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('b'), -1)); + assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('b'), 0)); + assertEquals(1, sb.lastIndexOf(StrMatcher.charMatcher('b'), 1)); + assertEquals(1, sb.lastIndexOf(StrMatcher.charMatcher('b'), 2)); + assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 3)); + assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 4)); + assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 5)); + assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 6)); + + assertEquals(-1, sb.lastIndexOf(StrMatcher.spaceMatcher(), -2)); + assertEquals(-1, sb.lastIndexOf(StrMatcher.spaceMatcher(), 0)); + assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher(), 2)); + assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher(), 4)); + assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher(), 20)); + + assertEquals(-1, sb.lastIndexOf(StrMatcher.noneMatcher(), 0)); + assertEquals(-1, sb.lastIndexOf((StrMatcher) null, 0)); + + sb.append(" A1 junction with A2"); + assertEquals(-1, sb.lastIndexOf(A_NUMBER_MATCHER, 5)); + assertEquals(-1, sb.lastIndexOf(A_NUMBER_MATCHER, 6)); // A matches, 1 is outside bounds + assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER, 7)); + assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER, 22)); + assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER, 23)); // A matches, 2 is outside bounds + assertEquals(23, sb.lastIndexOf(A_NUMBER_MATCHER, 24)); + } + + static final StrMatcher A_NUMBER_MATCHER = new StrMatcher() { + @Override + public int isMatch(final char[] buffer, int pos, final int bufferStart, final int bufferEnd) { + if (buffer[pos] == 'A') { + pos++; + if (pos < bufferEnd && buffer[pos] >= '0' && buffer[pos] <= '9') { + return 2; + } + } + return 0; + } + }; + + //----------------------------------------------------------------------- + @Test + public void testAsTokenizer() throws Exception { + // from Javadoc + final StrBuilder b = new StrBuilder(); + b.append("a b "); + final StrTokenizer t = b.asTokenizer(); + + final String[] tokens1 = t.getTokenArray(); + assertEquals(2, tokens1.length); + assertEquals("a", tokens1[0]); + assertEquals("b", tokens1[1]); + assertEquals(2, t.size()); + + b.append("c d "); + final String[] tokens2 = t.getTokenArray(); + assertEquals(2, tokens2.length); + assertEquals("a", tokens2[0]); + assertEquals("b", tokens2[1]); + assertEquals(2, t.size()); + assertEquals("a", t.next()); + assertEquals("b", t.next()); + + t.reset(); + final String[] tokens3 = t.getTokenArray(); + assertEquals(4, tokens3.length); + assertEquals("a", tokens3[0]); + assertEquals("b", tokens3[1]); + assertEquals("c", tokens3[2]); + assertEquals("d", tokens3[3]); + assertEquals(4, t.size()); + assertEquals("a", t.next()); + assertEquals("b", t.next()); + assertEquals("c", t.next()); + assertEquals("d", t.next()); + + assertEquals("a b c d ", t.getContent()); + } + + // ----------------------------------------------------------------------- + @Test + public void testAsReader() throws Exception { + final StrBuilder sb = new StrBuilder("some text"); + Reader reader = sb.asReader(); + assertTrue(reader.ready()); + final char[] buf = new char[40]; + assertEquals(9, reader.read(buf)); + assertEquals("some text", new String(buf, 0, 9)); + + assertEquals(-1, reader.read()); + assertFalse(reader.ready()); + assertEquals(0, reader.skip(2)); + assertEquals(0, reader.skip(-1)); + + assertTrue(reader.markSupported()); + reader = sb.asReader(); + assertEquals('s', reader.read()); + reader.mark(-1); + char[] array = new char[3]; + assertEquals(3, reader.read(array, 0, 3)); + assertEquals('o', array[0]); + assertEquals('m', array[1]); + assertEquals('e', array[2]); + reader.reset(); + assertEquals(1, reader.read(array, 1, 1)); + assertEquals('o', array[0]); + assertEquals('o', array[1]); + assertEquals('e', array[2]); + assertEquals(2, reader.skip(2)); + assertEquals(' ', reader.read()); + + assertTrue(reader.ready()); + reader.close(); + assertTrue(reader.ready()); + + reader = sb.asReader(); + array = new char[3]; + try { + reader.read(array, -1, 0); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + try { + reader.read(array, 0, -1); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + try { + reader.read(array, 100, 1); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + try { + reader.read(array, 0, 100); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + try { + reader.read(array, Integer.MAX_VALUE, Integer.MAX_VALUE); + fail(); + } catch (final IndexOutOfBoundsException ex) {} + + assertEquals(0, reader.read(array, 0, 0)); + assertEquals(0, array[0]); + assertEquals(0, array[1]); + assertEquals(0, array[2]); + + reader.skip(9); + assertEquals(-1, reader.read(array, 0, 1)); + + reader.reset(); + array = new char[30]; + assertEquals(9, reader.read(array, 0, 30)); + } + + //----------------------------------------------------------------------- + @Test + public void testAsWriter() throws Exception { + final StrBuilder sb = new StrBuilder("base"); + final Writer writer = sb.asWriter(); + + writer.write('l'); + assertEquals("basel", sb.toString()); + + writer.write(new char[] {'i', 'n'}); + assertEquals("baselin", sb.toString()); + + writer.write(new char[] {'n', 'e', 'r'}, 1, 2); + assertEquals("baseliner", sb.toString()); + + writer.write(" rout"); + assertEquals("baseliner rout", sb.toString()); + + writer.write("ping that server", 1, 3); + assertEquals("baseliner routing", sb.toString()); + + writer.flush(); // no effect + assertEquals("baseliner routing", sb.toString()); + + writer.close(); // no effect + assertEquals("baseliner routing", sb.toString()); + + writer.write(" hi"); // works after close + assertEquals("baseliner routing hi", sb.toString()); + + sb.setLength(4); // mix and match + writer.write('d'); + assertEquals("based", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testEqualsIgnoreCase() { + final StrBuilder sb1 = new StrBuilder(); + final StrBuilder sb2 = new StrBuilder(); + assertTrue(sb1.equalsIgnoreCase(sb1)); + assertTrue(sb1.equalsIgnoreCase(sb2)); + assertTrue(sb2.equalsIgnoreCase(sb2)); + + sb1.append("abc"); + assertFalse(sb1.equalsIgnoreCase(sb2)); + + sb2.append("ABC"); + assertTrue(sb1.equalsIgnoreCase(sb2)); + + sb2.clear().append("abc"); + assertTrue(sb1.equalsIgnoreCase(sb2)); + assertTrue(sb1.equalsIgnoreCase(sb1)); + assertTrue(sb2.equalsIgnoreCase(sb2)); + + sb2.clear().append("aBc"); + assertTrue(sb1.equalsIgnoreCase(sb2)); + } + + //----------------------------------------------------------------------- + @Test + public void testEquals() { + final StrBuilder sb1 = new StrBuilder(); + final StrBuilder sb2 = new StrBuilder(); + assertTrue(sb1.equals(sb2)); + assertTrue(sb1.equals(sb1)); + assertTrue(sb2.equals(sb2)); + assertTrue(sb1.equals((Object) sb2)); + + sb1.append("abc"); + assertFalse(sb1.equals(sb2)); + assertFalse(sb1.equals((Object) sb2)); + + sb2.append("ABC"); + assertFalse(sb1.equals(sb2)); + assertFalse(sb1.equals((Object) sb2)); + + sb2.clear().append("abc"); + assertTrue(sb1.equals(sb2)); + assertTrue(sb1.equals((Object) sb2)); + + assertFalse(sb1.equals(Integer.valueOf(1))); + assertFalse(sb1.equals("abc")); + } + + @Test + public void test_LANG_1131_EqualsWithNullStrBuilder() throws Exception { + final StrBuilder sb = new StrBuilder(); + final StrBuilder other = null; + assertFalse(sb.equals(other)); + } + + //----------------------------------------------------------------------- + @Test + public void testHashCode() { + final StrBuilder sb = new StrBuilder(); + final int hc1a = sb.hashCode(); + final int hc1b = sb.hashCode(); + assertEquals(0, hc1a); + assertEquals(hc1a, hc1b); + + sb.append("abc"); + final int hc2a = sb.hashCode(); + final int hc2b = sb.hashCode(); + assertTrue(hc2a != 0); + assertEquals(hc2a, hc2b); + } + + //----------------------------------------------------------------------- + @Test + public void testToString() { + final StrBuilder sb = new StrBuilder("abc"); + assertEquals("abc", sb.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testToStringBuffer() { + final StrBuilder sb = new StrBuilder(); + assertEquals(new StringBuffer().toString(), sb.toStringBuffer().toString()); + + sb.append("junit"); + assertEquals(new StringBuffer("junit").toString(), sb.toStringBuffer().toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testToStringBuilder() { + final StrBuilder sb = new StrBuilder(); + assertEquals(new StringBuilder().toString(), sb.toStringBuilder().toString()); + + sb.append("junit"); + assertEquals(new StringBuilder("junit").toString(), sb.toStringBuilder().toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testLang294() { + final StrBuilder sb = new StrBuilder("\n%BLAH%\nDo more stuff\neven more stuff\n%BLAH%\n"); + sb.deleteAll("\n%BLAH%"); + assertEquals("\nDo more stuff\neven more stuff\n", sb.toString()); + } + + @Test + public void testIndexOfLang294() { + final StrBuilder sb = new StrBuilder("onetwothree"); + sb.deleteFirst("three"); + assertEquals(-1, sb.indexOf("three")); + } + + //----------------------------------------------------------------------- + @Test + public void testLang295() { + final StrBuilder sb = new StrBuilder("onetwothree"); + sb.deleteFirst("three"); + assertFalse( "The contains(char) method is looking beyond the end of the string", sb.contains('h')); + assertEquals( "The indexOf(char) method is looking beyond the end of the string", -1, sb.indexOf('h')); + } + + //----------------------------------------------------------------------- + @Test + public void testLang412Right() { + final StrBuilder sb = new StrBuilder(); + sb.appendFixedWidthPadRight(null, 10, '*'); + assertEquals( "Failed to invoke appendFixedWidthPadRight correctly", "**********", sb.toString()); + } + + @Test + public void testLang412Left() { + final StrBuilder sb = new StrBuilder(); + sb.appendFixedWidthPadLeft(null, 10, '*'); + assertEquals( "Failed to invoke appendFixedWidthPadLeft correctly", "**********", sb.toString()); + } + + @Test + public void testAsBuilder() { + final StrBuilder sb = new StrBuilder().appendAll("Lorem", " ", "ipsum", " ", "dolor"); + assertEquals(sb.toString(), sb.build()); + } + + //----------------------------------------------------------------------- + @Test + public void testAppendCharBuffer() { + final StrBuilder sb1 = new StrBuilder(); + final CharBuffer buf = CharBuffer.allocate(10); + buf.append("0123456789"); + buf.flip(); + sb1.append(buf); + assertEquals("0123456789", sb1.toString()); + + final StrBuilder sb2 = new StrBuilder(); + sb2.append(buf, 1, 8); + assertEquals("12345678", sb2.toString()); + } + + //----------------------------------------------------------------------- + @Test + public void testAppendToWriter() throws Exception { + final StrBuilder sb = new StrBuilder("1234567890"); + final StringWriter writer = new StringWriter(); + writer.append("Test "); + + sb.appendTo(writer); + + assertEquals("Test 1234567890", writer.toString()); + } + + @Test + public void testAppendToStringBuilder() throws Exception { + final StrBuilder sb = new StrBuilder("1234567890"); + final StringBuilder builder = new StringBuilder("Test "); + + sb.appendTo(builder); + + assertEquals("Test 1234567890", builder.toString()); + } + + @Test + public void testAppendToStringBuffer() throws Exception { + final StrBuilder sb = new StrBuilder("1234567890"); + final StringBuffer buffer = new StringBuffer("Test "); + + sb.appendTo(buffer); + + assertEquals("Test 1234567890", buffer.toString()); + } + + @Test + public void testAppendToCharBuffer() throws Exception { + final StrBuilder sb = new StrBuilder("1234567890"); + final String text = "Test "; + final CharBuffer buffer = CharBuffer.allocate(sb.size() + text.length()); + buffer.put(text); + + sb.appendTo(buffer); + + buffer.flip(); + assertEquals("Test 1234567890", buffer.toString()); + } +}
http://git-wip-us.apache.org/repos/asf/commons-text/blob/6f24aa45/src/test/java/org/apache/commons/text/StrLookupTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/StrLookupTest.java b/src/test/java/org/apache/commons/text/StrLookupTest.java new file mode 100644 index 0000000..dfd8933 --- /dev/null +++ b/src/test/java/org/apache/commons/text/StrLookupTest.java @@ -0,0 +1,115 @@ +/* + * 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.text; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import java.util.HashMap; +import java.util.Map; +import java.util.Properties; + +import org.junit.Test; + +/** + * Test class for {@link StrLookup}. + */ +public class StrLookupTest { + + //----------------------------------------------------------------------- + @Test + public void testNoneLookup() { + assertEquals(null, StrLookup.noneLookup().lookup(null)); + assertEquals(null, StrLookup.noneLookup().lookup("")); + assertEquals(null, StrLookup.noneLookup().lookup("any")); + } + + @Test + public void testSystemProperiesLookup() { + assertEquals(System.getProperty("os.name"), StrLookup.systemPropertiesLookup().lookup("os.name")); + assertEquals(null, StrLookup.systemPropertiesLookup().lookup("")); + assertEquals(null, StrLookup.systemPropertiesLookup().lookup("other")); + try { + StrLookup.systemPropertiesLookup().lookup(null); + fail(); + } catch (final NullPointerException ex) { + // expected + } + } + + /** + * Tests that a lookup object for system properties can deal with a full + * replacement of the system properties object. This test is related to + * LANG-1055. + */ + @Test + public void testSystemPropertiesLookupReplacedProperties() { + final Properties oldProperties = System.getProperties(); + final String osName = "os.name"; + final String newOsName = oldProperties.getProperty(osName) + "_changed"; + + final StrLookup<String> sysLookup = StrLookup.systemPropertiesLookup(); + final Properties newProps = new Properties(); + newProps.setProperty(osName, newOsName); + System.setProperties(newProps); + try { + assertEquals("Changed properties not detected", newOsName, sysLookup.lookup(osName)); + } finally { + System.setProperties(oldProperties); + } + } + + /** + * Tests that a lookup object for system properties sees changes on system + * properties. This test is related to LANG-1141. + */ + @Test + public void testSystemPropertiesLookupUpdatedProperty() { + final String osName = "os.name"; + final String oldOs = System.getProperty(osName); + final String newOsName = oldOs + "_changed"; + + final StrLookup<String> sysLookup = StrLookup.systemPropertiesLookup(); + System.setProperty(osName, newOsName); + try { + assertEquals("Changed properties not detected", newOsName, sysLookup.lookup(osName)); + } finally { + System.setProperty(osName, oldOs); + } + } + + @Test + public void testMapLookup() { + final Map<String, Object> map = new HashMap<>(); + map.put("key", "value"); + map.put("number", Integer.valueOf(2)); + assertEquals("value", StrLookup.mapLookup(map).lookup("key")); + assertEquals("2", StrLookup.mapLookup(map).lookup("number")); + assertEquals(null, StrLookup.mapLookup(map).lookup(null)); + assertEquals(null, StrLookup.mapLookup(map).lookup("")); + assertEquals(null, StrLookup.mapLookup(map).lookup("other")); + } + + @Test + public void testMapLookup_nullMap() { + final Map<String, ?> map = null; + assertEquals(null, StrLookup.mapLookup(map).lookup(null)); + assertEquals(null, StrLookup.mapLookup(map).lookup("")); + assertEquals(null, StrLookup.mapLookup(map).lookup("any")); + } + +} http://git-wip-us.apache.org/repos/asf/commons-text/blob/6f24aa45/src/test/java/org/apache/commons/text/StrMatcherTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/StrMatcherTest.java b/src/test/java/org/apache/commons/text/StrMatcherTest.java new file mode 100644 index 0000000..2b365e0 --- /dev/null +++ b/src/test/java/org/apache/commons/text/StrMatcherTest.java @@ -0,0 +1,214 @@ +/* + * 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.text; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertSame; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +/** + * Unit tests for {@link StrMatcher}. + */ +public class StrMatcherTest { + + private static final char[] BUFFER1 = "0,1\t2 3\n\r\f\u0000'\"".toCharArray(); + + private static final char[] BUFFER2 = "abcdef".toCharArray(); + + + //----------------------------------------------------------------------- + @Test + public void testCommaMatcher() { + final StrMatcher matcher = StrMatcher.commaMatcher(); + assertSame(matcher, StrMatcher.commaMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 0)); + assertEquals(1, matcher.isMatch(BUFFER1, 1)); + assertEquals(0, matcher.isMatch(BUFFER1, 2)); + } + + //----------------------------------------------------------------------- + @Test + public void testTabMatcher() { + final StrMatcher matcher = StrMatcher.tabMatcher(); + assertSame(matcher, StrMatcher.tabMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 2)); + assertEquals(1, matcher.isMatch(BUFFER1, 3)); + assertEquals(0, matcher.isMatch(BUFFER1, 4)); + } + + //----------------------------------------------------------------------- + @Test + public void testSpaceMatcher() { + final StrMatcher matcher = StrMatcher.spaceMatcher(); + assertSame(matcher, StrMatcher.spaceMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 4)); + assertEquals(1, matcher.isMatch(BUFFER1, 5)); + assertEquals(0, matcher.isMatch(BUFFER1, 6)); + } + + //----------------------------------------------------------------------- + @Test + public void testSplitMatcher() { + final StrMatcher matcher = StrMatcher.splitMatcher(); + assertSame(matcher, StrMatcher.splitMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 2)); + assertEquals(1, matcher.isMatch(BUFFER1, 3)); + assertEquals(0, matcher.isMatch(BUFFER1, 4)); + assertEquals(1, matcher.isMatch(BUFFER1, 5)); + assertEquals(0, matcher.isMatch(BUFFER1, 6)); + assertEquals(1, matcher.isMatch(BUFFER1, 7)); + assertEquals(1, matcher.isMatch(BUFFER1, 8)); + assertEquals(1, matcher.isMatch(BUFFER1, 9)); + assertEquals(0, matcher.isMatch(BUFFER1, 10)); + } + + //----------------------------------------------------------------------- + @Test + public void testTrimMatcher() { + final StrMatcher matcher = StrMatcher.trimMatcher(); + assertSame(matcher, StrMatcher.trimMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 2)); + assertEquals(1, matcher.isMatch(BUFFER1, 3)); + assertEquals(0, matcher.isMatch(BUFFER1, 4)); + assertEquals(1, matcher.isMatch(BUFFER1, 5)); + assertEquals(0, matcher.isMatch(BUFFER1, 6)); + assertEquals(1, matcher.isMatch(BUFFER1, 7)); + assertEquals(1, matcher.isMatch(BUFFER1, 8)); + assertEquals(1, matcher.isMatch(BUFFER1, 9)); + assertEquals(1, matcher.isMatch(BUFFER1, 10)); + } + + //----------------------------------------------------------------------- + @Test + public void testSingleQuoteMatcher() { + final StrMatcher matcher = StrMatcher.singleQuoteMatcher(); + assertSame(matcher, StrMatcher.singleQuoteMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 10)); + assertEquals(1, matcher.isMatch(BUFFER1, 11)); + assertEquals(0, matcher.isMatch(BUFFER1, 12)); + } + + //----------------------------------------------------------------------- + @Test + public void testDoubleQuoteMatcher() { + final StrMatcher matcher = StrMatcher.doubleQuoteMatcher(); + assertSame(matcher, StrMatcher.doubleQuoteMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 11)); + assertEquals(1, matcher.isMatch(BUFFER1, 12)); + } + + //----------------------------------------------------------------------- + @Test + public void testQuoteMatcher() { + final StrMatcher matcher = StrMatcher.quoteMatcher(); + assertSame(matcher, StrMatcher.quoteMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 10)); + assertEquals(1, matcher.isMatch(BUFFER1, 11)); + assertEquals(1, matcher.isMatch(BUFFER1, 12)); + } + + //----------------------------------------------------------------------- + @Test + public void testNoneMatcher() { + final StrMatcher matcher = StrMatcher.noneMatcher(); + assertSame(matcher, StrMatcher.noneMatcher()); + assertEquals(0, matcher.isMatch(BUFFER1, 0)); + assertEquals(0, matcher.isMatch(BUFFER1, 1)); + assertEquals(0, matcher.isMatch(BUFFER1, 2)); + assertEquals(0, matcher.isMatch(BUFFER1, 3)); + assertEquals(0, matcher.isMatch(BUFFER1, 4)); + assertEquals(0, matcher.isMatch(BUFFER1, 5)); + assertEquals(0, matcher.isMatch(BUFFER1, 6)); + assertEquals(0, matcher.isMatch(BUFFER1, 7)); + assertEquals(0, matcher.isMatch(BUFFER1, 8)); + assertEquals(0, matcher.isMatch(BUFFER1, 9)); + assertEquals(0, matcher.isMatch(BUFFER1, 10)); + assertEquals(0, matcher.isMatch(BUFFER1, 11)); + assertEquals(0, matcher.isMatch(BUFFER1, 12)); + } + + //----------------------------------------------------------------------- + @Test + public void testCharMatcher_char() { + final StrMatcher matcher = StrMatcher.charMatcher('c'); + assertEquals(0, matcher.isMatch(BUFFER2, 0)); + assertEquals(0, matcher.isMatch(BUFFER2, 1)); + assertEquals(1, matcher.isMatch(BUFFER2, 2)); + assertEquals(0, matcher.isMatch(BUFFER2, 3)); + assertEquals(0, matcher.isMatch(BUFFER2, 4)); + assertEquals(0, matcher.isMatch(BUFFER2, 5)); + } + + //----------------------------------------------------------------------- + @Test + public void testCharSetMatcher_String() { + final StrMatcher matcher = StrMatcher.charSetMatcher("ace"); + assertEquals(1, matcher.isMatch(BUFFER2, 0)); + assertEquals(0, matcher.isMatch(BUFFER2, 1)); + assertEquals(1, matcher.isMatch(BUFFER2, 2)); + assertEquals(0, matcher.isMatch(BUFFER2, 3)); + assertEquals(1, matcher.isMatch(BUFFER2, 4)); + assertEquals(0, matcher.isMatch(BUFFER2, 5)); + assertSame(StrMatcher.noneMatcher(), StrMatcher.charSetMatcher("")); + assertSame(StrMatcher.noneMatcher(), StrMatcher.charSetMatcher((String) null)); + assertTrue(StrMatcher.charSetMatcher("a") instanceof StrMatcher.CharMatcher); + } + + //----------------------------------------------------------------------- + @Test + public void testCharSetMatcher_charArray() { + final StrMatcher matcher = StrMatcher.charSetMatcher("ace".toCharArray()); + assertEquals(1, matcher.isMatch(BUFFER2, 0)); + assertEquals(0, matcher.isMatch(BUFFER2, 1)); + assertEquals(1, matcher.isMatch(BUFFER2, 2)); + assertEquals(0, matcher.isMatch(BUFFER2, 3)); + assertEquals(1, matcher.isMatch(BUFFER2, 4)); + assertEquals(0, matcher.isMatch(BUFFER2, 5)); + assertSame(StrMatcher.noneMatcher(), StrMatcher.charSetMatcher(new char[0])); + assertSame(StrMatcher.noneMatcher(), StrMatcher.charSetMatcher((char[]) null)); + assertTrue(StrMatcher.charSetMatcher("a".toCharArray()) instanceof StrMatcher.CharMatcher); + } + + //----------------------------------------------------------------------- + @Test + public void testStringMatcher_String() { + final StrMatcher matcher = StrMatcher.stringMatcher("bc"); + assertEquals(0, matcher.isMatch(BUFFER2, 0)); + assertEquals(2, matcher.isMatch(BUFFER2, 1)); + assertEquals(0, matcher.isMatch(BUFFER2, 2)); + assertEquals(0, matcher.isMatch(BUFFER2, 3)); + assertEquals(0, matcher.isMatch(BUFFER2, 4)); + assertEquals(0, matcher.isMatch(BUFFER2, 5)); + assertSame(StrMatcher.noneMatcher(), StrMatcher.stringMatcher("")); + assertSame(StrMatcher.noneMatcher(), StrMatcher.stringMatcher((String) null)); + } + + //----------------------------------------------------------------------- + @Test + public void testMatcherIndices() { + // remember that the API contract is tight for the isMatch() method + // all the onus is on the caller, so invalid inputs are not + // the concern of StrMatcher, and are not bugs + final StrMatcher matcher = StrMatcher.stringMatcher("bc"); + assertEquals(2, matcher.isMatch(BUFFER2, 1, 1, BUFFER2.length)); + assertEquals(2, matcher.isMatch(BUFFER2, 1, 0, 3)); + assertEquals(0, matcher.isMatch(BUFFER2, 1, 0, 2)); + } + +}
