commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From chtom...@apache.org
Subject [25/27] [text] TEXT-61: context.xml and test packages
Date Tue, 24 Jan 2017 12:31:06 GMT
http://git-wip-us.apache.org/repos/asf/commons-text/blob/165c8e60/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
deleted file mode 100644
index 36f4138..0000000
--- a/src/test/java/org/apache/commons/text/StrBuilderTest.java
+++ /dev/null
@@ -1,2010 +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;
-
-import org.apache.commons.text.beta.StrBuilder;
-import org.apache.commons.text.beta.StrMatcher;
-import org.apache.commons.text.beta.StrTokenizer;
-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/165c8e60/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
deleted file mode 100644
index d45dc7f..0000000
--- a/src/test/java/org/apache/commons/text/StrLookupTest.java
+++ /dev/null
@@ -1,116 +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;
-
-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.apache.commons.text.beta.StrLookup;
-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/165c8e60/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
deleted file mode 100644
index 112e9cb..0000000
--- a/src/test/java/org/apache/commons/text/StrMatcherTest.java
+++ /dev/null
@@ -1,215 +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;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-
-import org.apache.commons.text.beta.StrMatcher;
-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));
-    }
-
-}


Mime
View raw message