http://git-wip-us.apache.org/repos/asf/commons-text/blob/c7cf533d/src/test/java/org/apache/commons/text/beta/StrBuilderTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/beta/StrBuilderTest.java b/src/test/java/org/apache/commons/text/beta/StrBuilderTest.java deleted file mode 100644 index 91700f0..0000000 --- a/src/test/java/org/apache/commons/text/beta/StrBuilderTest.java +++ /dev/null @@ -1,2007 +0,0 @@ -/* - * 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.beta; - -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; - -/** - * 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(0, sb.toCharArray().length); - - 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(0, sb.toCharArray(0, 0).length); - - 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/c7cf533d/src/test/java/org/apache/commons/text/beta/StrLookupTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/beta/StrLookupTest.java b/src/test/java/org/apache/commons/text/beta/StrLookupTest.java deleted file mode 100644 index 77ffc5f..0000000 --- a/src/test/java/org/apache/commons/text/beta/StrLookupTest.java +++ /dev/null @@ -1,115 +0,0 @@ -/* - * 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.beta; - -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/c7cf533d/src/test/java/org/apache/commons/text/beta/StrMatcherTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/text/beta/StrMatcherTest.java b/src/test/java/org/apache/commons/text/beta/StrMatcherTest.java deleted file mode 100644 index ef9356a..0000000 --- a/src/test/java/org/apache/commons/text/beta/StrMatcherTest.java +++ /dev/null @@ -1,214 +0,0 @@ -/* - * 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.beta; - -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)); - } - -}
