• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements.  See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License.  You may obtain a copy of the License at
8  *
9  *      http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 package org.apache.commons.lang3.text;
19 
20 import static org.junit.jupiter.api.Assertions.assertArrayEquals;
21 import static org.junit.jupiter.api.Assertions.assertEquals;
22 import static org.junit.jupiter.api.Assertions.assertFalse;
23 import static org.junit.jupiter.api.Assertions.assertNotEquals;
24 import static org.junit.jupiter.api.Assertions.assertNotNull;
25 import static org.junit.jupiter.api.Assertions.assertNotSame;
26 import static org.junit.jupiter.api.Assertions.assertNull;
27 import static org.junit.jupiter.api.Assertions.assertSame;
28 import static org.junit.jupiter.api.Assertions.assertThrows;
29 import static org.junit.jupiter.api.Assertions.assertTrue;
30 
31 import java.io.IOException;
32 import java.io.Reader;
33 import java.io.StringReader;
34 import java.io.StringWriter;
35 import java.io.Writer;
36 import java.nio.CharBuffer;
37 
38 import org.apache.commons.lang3.AbstractLangTest;
39 import org.apache.commons.lang3.ArrayUtils;
40 import org.junit.jupiter.api.Test;
41 
42 /**
43  * Unit tests for {@link org.apache.commons.lang3.text.StrBuilder}.
44  */
45 @Deprecated
46 public class StrBuilderTest extends AbstractLangTest {
47 
48     @Test
testConstructors()49     public void testConstructors() {
50         final StrBuilder sb0 = new StrBuilder();
51         assertEquals(32, sb0.capacity());
52         assertEquals(0, sb0.length());
53         assertEquals(0, sb0.size());
54 
55         final StrBuilder sb1 = new StrBuilder(32);
56         assertEquals(32, sb1.capacity());
57         assertEquals(0, sb1.length());
58         assertEquals(0, sb1.size());
59 
60         final StrBuilder sb2 = new StrBuilder(0);
61         assertEquals(32, sb2.capacity());
62         assertEquals(0, sb2.length());
63         assertEquals(0, sb2.size());
64 
65         final StrBuilder sb3 = new StrBuilder(-1);
66         assertEquals(32, sb3.capacity());
67         assertEquals(0, sb3.length());
68         assertEquals(0, sb3.size());
69 
70         final StrBuilder sb4 = new StrBuilder(1);
71         assertEquals(1, sb4.capacity());
72         assertEquals(0, sb4.length());
73         assertEquals(0, sb4.size());
74 
75         final StrBuilder sb5 = new StrBuilder(null);
76         assertEquals(32, sb5.capacity());
77         assertEquals(0, sb5.length());
78         assertEquals(0, sb5.size());
79 
80         final StrBuilder sb6 = new StrBuilder("");
81         assertEquals(32, sb6.capacity());
82         assertEquals(0, sb6.length());
83         assertEquals(0, sb6.size());
84 
85         final StrBuilder sb7 = new StrBuilder("foo");
86         assertEquals(35, sb7.capacity());
87         assertEquals(3, sb7.length());
88         assertEquals(3, sb7.size());
89     }
90 
91     @Test
testChaining()92     public void testChaining() {
93         final StrBuilder sb = new StrBuilder();
94         assertSame(sb, sb.setNewLineText(null));
95         assertSame(sb, sb.setNullText(null));
96         assertSame(sb, sb.setLength(1));
97         assertSame(sb, sb.setCharAt(0, 'a'));
98         assertSame(sb, sb.ensureCapacity(0));
99         assertSame(sb, sb.minimizeCapacity());
100         assertSame(sb, sb.clear());
101         assertSame(sb, sb.reverse());
102         assertSame(sb, sb.trim());
103     }
104 
105     @Test
testReadFromReader()106     public void testReadFromReader() throws Exception {
107         String s = "";
108         for (int i = 0; i < 100; ++i) {
109             final StrBuilder sb = new StrBuilder();
110             final int len = sb.readFrom(new StringReader(s));
111 
112             assertEquals(s.length(), len);
113             assertEquals(s, sb.toString());
114 
115             s += Integer.toString(i);
116         }
117     }
118 
119     @Test
testReadFromReaderAppendsToEnd()120     public void testReadFromReaderAppendsToEnd() throws Exception {
121         final StrBuilder sb = new StrBuilder("Test");
122         sb.readFrom(new StringReader(" 123"));
123         assertEquals("Test 123", sb.toString());
124     }
125 
126     @Test
testReadFromCharBuffer()127     public void testReadFromCharBuffer() throws Exception {
128         String s = "";
129         for (int i = 0; i < 100; ++i) {
130             final StrBuilder sb = new StrBuilder();
131             final int len = sb.readFrom(CharBuffer.wrap(s));
132 
133             assertEquals(s.length(), len);
134             assertEquals(s, sb.toString());
135 
136             s += Integer.toString(i);
137         }
138     }
139 
140     @Test
testReadFromCharBufferAppendsToEnd()141     public void testReadFromCharBufferAppendsToEnd() throws Exception {
142         final StrBuilder sb = new StrBuilder("Test");
143         sb.readFrom(CharBuffer.wrap(" 123"));
144         assertEquals("Test 123", sb.toString());
145     }
146 
147     @Test
testReadFromReadable()148     public void testReadFromReadable() throws Exception {
149         String s = "";
150         for (int i = 0; i < 100; ++i) {
151             final StrBuilder sb = new StrBuilder();
152             final int len = sb.readFrom(new MockReadable(s));
153 
154             assertEquals(s.length(), len);
155             assertEquals(s, sb.toString());
156 
157             s += Integer.toString(i);
158         }
159     }
160 
161     @Test
testReadFromReadableAppendsToEnd()162     public void testReadFromReadableAppendsToEnd() throws Exception {
163         final StrBuilder sb = new StrBuilder("Test");
164         sb.readFrom(new MockReadable(" 123"));
165         assertEquals("Test 123", sb.toString());
166     }
167 
168     private static class MockReadable implements Readable {
169 
170         private final CharBuffer src;
171 
MockReadable(final String src)172         MockReadable(final String src) {
173             this.src = CharBuffer.wrap(src);
174         }
175 
176         @Override
read(final CharBuffer cb)177         public int read(final CharBuffer cb) throws IOException {
178             return src.read(cb);
179         }
180     }
181 
182     @Test
testGetSetNewLineText()183     public void testGetSetNewLineText() {
184         final StrBuilder sb = new StrBuilder();
185         assertNull(sb.getNewLineText());
186 
187         sb.setNewLineText("#");
188         assertEquals("#", sb.getNewLineText());
189 
190         sb.setNewLineText("");
191         assertEquals("", sb.getNewLineText());
192 
193         sb.setNewLineText(null);
194         assertNull(sb.getNewLineText());
195     }
196 
197     @Test
testGetSetNullText()198     public void testGetSetNullText() {
199         final StrBuilder sb = new StrBuilder();
200         assertNull(sb.getNullText());
201 
202         sb.setNullText("null");
203         assertEquals("null", sb.getNullText());
204 
205         sb.setNullText("");
206         assertNull(sb.getNullText());
207 
208         sb.setNullText("NULL");
209         assertEquals("NULL", sb.getNullText());
210 
211         sb.setNullText(null);
212         assertNull(sb.getNullText());
213     }
214 
215     @Test
testCapacityAndLength()216     public void testCapacityAndLength() {
217         final StrBuilder sb = new StrBuilder();
218         assertEquals(32, sb.capacity());
219         assertEquals(0, sb.length());
220         assertEquals(0, sb.size());
221         assertTrue(sb.isEmpty());
222 
223         sb.minimizeCapacity();
224         assertEquals(0, sb.capacity());
225         assertEquals(0, sb.length());
226         assertEquals(0, sb.size());
227         assertTrue(sb.isEmpty());
228 
229         sb.ensureCapacity(32);
230         assertTrue(sb.capacity() >= 32);
231         assertEquals(0, sb.length());
232         assertEquals(0, sb.size());
233         assertTrue(sb.isEmpty());
234 
235         sb.append("foo");
236         assertTrue(sb.capacity() >= 32);
237         assertEquals(3, sb.length());
238         assertEquals(3, sb.size());
239         assertFalse(sb.isEmpty());
240 
241         sb.clear();
242         assertTrue(sb.capacity() >= 32);
243         assertEquals(0, sb.length());
244         assertEquals(0, sb.size());
245         assertTrue(sb.isEmpty());
246 
247         sb.append("123456789012345678901234567890123");
248         assertTrue(sb.capacity() > 32);
249         assertEquals(33, sb.length());
250         assertEquals(33, sb.size());
251         assertFalse(sb.isEmpty());
252 
253         sb.ensureCapacity(16);
254         assertTrue(sb.capacity() > 16);
255         assertEquals(33, sb.length());
256         assertEquals(33, sb.size());
257         assertFalse(sb.isEmpty());
258 
259         sb.minimizeCapacity();
260         assertEquals(33, sb.capacity());
261         assertEquals(33, sb.length());
262         assertEquals(33, sb.size());
263         assertFalse(sb.isEmpty());
264 
265         assertThrows(
266                 IndexOutOfBoundsException.class,
267                 () -> sb.setLength(-1),
268                 "setLength(-1) expected StringIndexOutOfBoundsException");
269 
270         sb.setLength(33);
271         assertEquals(33, sb.capacity());
272         assertEquals(33, sb.length());
273         assertEquals(33, sb.size());
274         assertFalse(sb.isEmpty());
275 
276         sb.setLength(16);
277         assertTrue(sb.capacity() >= 16);
278         assertEquals(16, sb.length());
279         assertEquals(16, sb.size());
280         assertEquals("1234567890123456", sb.toString());
281         assertFalse(sb.isEmpty());
282 
283         sb.setLength(32);
284         assertTrue(sb.capacity() >= 32);
285         assertEquals(32, sb.length());
286         assertEquals(32, sb.size());
287         assertEquals("1234567890123456\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", sb.toString());
288         assertFalse(sb.isEmpty());
289 
290         sb.setLength(0);
291         assertTrue(sb.capacity() >= 32);
292         assertEquals(0, sb.length());
293         assertEquals(0, sb.size());
294         assertTrue(sb.isEmpty());
295     }
296 
297     @Test
testLength()298     public void testLength() {
299         final StrBuilder sb = new StrBuilder();
300         assertEquals(0, sb.length());
301 
302         sb.append("Hello");
303         assertEquals(5, sb.length());
304     }
305 
306     @Test
testSetLength()307     public void testSetLength() {
308         final StrBuilder sb = new StrBuilder();
309         sb.append("Hello");
310         sb.setLength(2);  // shorten
311         assertEquals("He", sb.toString());
312         sb.setLength(2);  // no change
313         assertEquals("He", sb.toString());
314         sb.setLength(3);  // lengthen
315         assertEquals("He\0", sb.toString());
316 
317         assertThrows(
318                 IndexOutOfBoundsException.class,
319                 () -> sb.setLength(-1),
320                 "setLength(-1) expected StringIndexOutOfBoundsException");
321     }
322 
323     @Test
testCapacity()324     public void testCapacity() {
325         final StrBuilder sb = new StrBuilder();
326         assertEquals(sb.buffer.length, sb.capacity());
327 
328         sb.append("HelloWorldHelloWorldHelloWorldHelloWorld");
329         assertEquals(sb.buffer.length, sb.capacity());
330     }
331 
332     @Test
testEnsureCapacity()333     public void testEnsureCapacity() {
334         final StrBuilder sb = new StrBuilder();
335         sb.ensureCapacity(2);
336         assertTrue(sb.capacity() >= 2);
337 
338         sb.ensureCapacity(-1);
339         assertTrue(sb.capacity() >= 0);
340 
341         sb.append("HelloWorld");
342         sb.ensureCapacity(40);
343         assertTrue(sb.capacity() >= 40);
344     }
345 
346     @Test
testMinimizeCapacity()347     public void testMinimizeCapacity() {
348         final StrBuilder sb = new StrBuilder();
349         sb.minimizeCapacity();
350         assertEquals(0, sb.capacity());
351 
352         sb.append("HelloWorld");
353         sb.minimizeCapacity();
354         assertEquals(10, sb.capacity());
355     }
356 
357     @Test
testSize()358     public void testSize() {
359         final StrBuilder sb = new StrBuilder();
360         assertEquals(0, sb.size());
361 
362         sb.append("Hello");
363         assertEquals(5, sb.size());
364     }
365 
366     @Test
testIsEmpty()367     public void testIsEmpty() {
368         final StrBuilder sb = new StrBuilder();
369         assertTrue(sb.isEmpty());
370 
371         sb.append("Hello");
372         assertFalse(sb.isEmpty());
373 
374         sb.clear();
375         assertTrue(sb.isEmpty());
376     }
377 
378     @Test
testClear()379     public void testClear() {
380         final StrBuilder sb = new StrBuilder();
381         sb.append("Hello");
382         sb.clear();
383         assertEquals(0, sb.length());
384         assertTrue(sb.buffer.length >= 5);
385     }
386 
387     @Test
testCharAt()388     public void testCharAt() {
389         final StrBuilder sb = new StrBuilder();
390         assertThrows(
391                 IndexOutOfBoundsException.class, () -> sb.charAt(0), "charAt(0) expected IndexOutOfBoundsException");
392         assertThrows(
393                 IndexOutOfBoundsException.class, () -> sb.charAt(-1), "charAt(-1) expected IndexOutOfBoundsException");
394         sb.append("foo");
395         assertEquals('f', sb.charAt(0));
396         assertEquals('o', sb.charAt(1));
397         assertEquals('o', sb.charAt(2));
398         assertThrows(
399                 IndexOutOfBoundsException.class, () -> sb.charAt(-1), "charAt(-1) expected IndexOutOfBoundsException");
400         assertThrows(
401                 IndexOutOfBoundsException.class, () -> sb.charAt(3), "charAt(3) expected IndexOutOfBoundsException");
402     }
403 
404     @Test
testSetCharAt()405     public void testSetCharAt() {
406         final StrBuilder sb = new StrBuilder();
407         assertThrows(
408                 IndexOutOfBoundsException.class,
409                 () -> sb.setCharAt(0, 'f'),
410                 "setCharAt(0, ) expected IndexOutOfBoundsException");
411         assertThrows(
412                 IndexOutOfBoundsException.class,
413                 () -> sb.setCharAt(-1, 'f'),
414                 "setCharAt(-1, ) expected IndexOutOfBoundsException");
415         sb.append("foo");
416         sb.setCharAt(0, 'b');
417         sb.setCharAt(1, 'a');
418         sb.setCharAt(2, 'r');
419         assertThrows(
420                 IndexOutOfBoundsException.class,
421                 () -> sb.setCharAt(3, '!'),
422                 "setCharAt(3, ) expected IndexOutOfBoundsException");
423         assertEquals("bar", sb.toString());
424     }
425 
426     @Test
testDeleteCharAt()427     public void testDeleteCharAt() {
428         final StrBuilder sb = new StrBuilder("abc");
429         sb.deleteCharAt(0);
430         assertEquals("bc", sb.toString());
431 
432         assertThrows(IndexOutOfBoundsException.class, () -> sb.deleteCharAt(1000));
433     }
434 
435     @Test
testToCharArray()436     public void testToCharArray() {
437         final StrBuilder sb = new StrBuilder();
438         assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, sb.toCharArray());
439 
440         char[] a = sb.toCharArray();
441         assertNotNull(a, "toCharArray() result is null");
442         assertEquals(0, a.length, "toCharArray() result is too large");
443 
444         sb.append("junit");
445         a = sb.toCharArray();
446         assertEquals(5, a.length, "toCharArray() result incorrect length");
447         assertArrayEquals("junit".toCharArray(), a, "toCharArray() result does not match");
448     }
449 
450     @Test
testToCharArrayIntInt()451     public void testToCharArrayIntInt() {
452         final StrBuilder sb = new StrBuilder();
453         assertEquals(ArrayUtils.EMPTY_CHAR_ARRAY, sb.toCharArray(0, 0));
454 
455         sb.append("junit");
456         char[] a = sb.toCharArray(0, 20); // too large test
457         assertEquals(5, a.length, "toCharArray(int, int) result incorrect length");
458         assertArrayEquals("junit".toCharArray(), a, "toCharArray(int, int) result does not match");
459 
460         a = sb.toCharArray(0, 4);
461         assertEquals(4, a.length, "toCharArray(int, int) result incorrect length");
462         assertArrayEquals("juni".toCharArray(), a, "toCharArray(int, int) result does not match");
463 
464         a = sb.toCharArray(0, 4);
465         assertEquals(4, a.length, "toCharArray(int, int) result incorrect length");
466         assertArrayEquals("juni".toCharArray(), a, "toCharArray(int, int) result does not match");
467 
468         a = sb.toCharArray(0, 1);
469         assertNotNull(a, "toCharArray(int, int) result is null");
470 
471         assertThrows(
472                 IndexOutOfBoundsException.class, () -> sb.toCharArray(-1, 5), "no string index out of bound on -1");
473 
474         assertThrows(
475                 IndexOutOfBoundsException.class, () -> sb.toCharArray(6, 5), "no string index out of bound on -1");
476     }
477 
478     @Test
testGetChars( )479     public void testGetChars ( ) {
480         final StrBuilder sb = new StrBuilder();
481 
482         char[] input = new char[10];
483         char[] a = sb.getChars(input);
484         assertSame (input, a);
485         assertArrayEquals(new char[10], a);
486 
487         sb.append("junit");
488         a = sb.getChars(input);
489         assertSame(input, a);
490         assertArrayEquals(new char[]{'j', 'u', 'n', 'i', 't', 0, 0, 0, 0, 0}, a);
491 
492         a = sb.getChars(null);
493         assertNotSame(input, a);
494         assertEquals(5, a.length);
495         assertArrayEquals("junit".toCharArray(), a);
496 
497         input = new char[5];
498         a = sb.getChars(input);
499         assertSame(input, a);
500 
501         input = new char[4];
502         a = sb.getChars(input);
503         assertNotSame(input, a);
504     }
505 
506     @Test
testGetCharsIntIntCharArrayInt( )507     public void testGetCharsIntIntCharArrayInt( ) {
508         final StrBuilder sb = new StrBuilder();
509 
510         sb.append("junit");
511         final char[] a = new char[5];
512         sb.getChars(0, 5, a, 0);
513         assertArrayEquals(new char[]{'j', 'u', 'n', 'i', 't'}, a);
514 
515         final char[] b = new char[5];
516         sb.getChars(0, 2, b, 3);
517         assertArrayEquals(new char[]{0, 0, 0, 'j', 'u'}, b);
518 
519         assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(-1, 0, b, 0));
520         assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(0, -1, b, 0));
521         assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(0, 20, b, 0));
522         assertThrows(IndexOutOfBoundsException.class, () -> sb.getChars(4, 2, b, 0));
523     }
524 
525     @Test
testDeleteIntInt()526     public void testDeleteIntInt() {
527         final StrBuilder sb = new StrBuilder("abc");
528         sb.delete(0, 1);
529         assertEquals("bc", sb.toString());
530         sb.delete(1, 2);
531         assertEquals("b", sb.toString());
532         sb.delete(0, 1);
533         assertEquals("", sb.toString());
534         sb.delete(0, 1000);
535         assertEquals("", sb.toString());
536 
537         assertThrows(IndexOutOfBoundsException.class, () -> sb.delete(1, 2));
538         assertThrows(IndexOutOfBoundsException.class, () -> sb.delete(-1, 1));
539         assertThrows(IndexOutOfBoundsException.class, () -> new StrBuilder("anything").delete(2, 1));
540     }
541 
542     @Test
testDeleteAll_char()543     public void testDeleteAll_char() {
544         StrBuilder sb = new StrBuilder("abcbccba");
545         sb.deleteAll('X');
546         assertEquals("abcbccba", sb.toString());
547         sb.deleteAll('a');
548         assertEquals("bcbccb", sb.toString());
549         sb.deleteAll('c');
550         assertEquals("bbb", sb.toString());
551         sb.deleteAll('b');
552         assertEquals("", sb.toString());
553 
554         sb = new StrBuilder("");
555         sb.deleteAll('b');
556         assertEquals("", sb.toString());
557     }
558 
559     @Test
testDeleteFirst_char()560     public void testDeleteFirst_char() {
561         StrBuilder sb = new StrBuilder("abcba");
562         sb.deleteFirst('X');
563         assertEquals("abcba", sb.toString());
564         sb.deleteFirst('a');
565         assertEquals("bcba", sb.toString());
566         sb.deleteFirst('c');
567         assertEquals("bba", sb.toString());
568         sb.deleteFirst('b');
569         assertEquals("ba", sb.toString());
570 
571         sb = new StrBuilder("");
572         sb.deleteFirst('b');
573         assertEquals("", sb.toString());
574     }
575 
576     @Test
testDeleteAll_String()577     public void testDeleteAll_String() {
578         StrBuilder sb = new StrBuilder("abcbccba");
579         sb.deleteAll((String) null);
580         assertEquals("abcbccba", sb.toString());
581         sb.deleteAll("");
582         assertEquals("abcbccba", sb.toString());
583 
584         sb.deleteAll("X");
585         assertEquals("abcbccba", sb.toString());
586         sb.deleteAll("a");
587         assertEquals("bcbccb", sb.toString());
588         sb.deleteAll("c");
589         assertEquals("bbb", sb.toString());
590         sb.deleteAll("b");
591         assertEquals("", sb.toString());
592 
593         sb = new StrBuilder("abcbccba");
594         sb.deleteAll("bc");
595         assertEquals("acba", sb.toString());
596 
597         sb = new StrBuilder("");
598         sb.deleteAll("bc");
599         assertEquals("", sb.toString());
600     }
601 
602     @Test
testDeleteFirst_String()603     public void testDeleteFirst_String() {
604         StrBuilder sb = new StrBuilder("abcbccba");
605         sb.deleteFirst((String) null);
606         assertEquals("abcbccba", sb.toString());
607         sb.deleteFirst("");
608         assertEquals("abcbccba", sb.toString());
609 
610         sb.deleteFirst("X");
611         assertEquals("abcbccba", sb.toString());
612         sb.deleteFirst("a");
613         assertEquals("bcbccba", sb.toString());
614         sb.deleteFirst("c");
615         assertEquals("bbccba", sb.toString());
616         sb.deleteFirst("b");
617         assertEquals("bccba", sb.toString());
618 
619         sb = new StrBuilder("abcbccba");
620         sb.deleteFirst("bc");
621         assertEquals("abccba", sb.toString());
622 
623         sb = new StrBuilder("");
624         sb.deleteFirst("bc");
625         assertEquals("", sb.toString());
626     }
627 
628     @Test
testDeleteAll_StrMatcher()629     public void testDeleteAll_StrMatcher() {
630         StrBuilder sb = new StrBuilder("A0xA1A2yA3");
631         sb.deleteAll((StrMatcher) null);
632         assertEquals("A0xA1A2yA3", sb.toString());
633         sb.deleteAll(A_NUMBER_MATCHER);
634         assertEquals("xy", sb.toString());
635 
636         sb = new StrBuilder("Ax1");
637         sb.deleteAll(A_NUMBER_MATCHER);
638         assertEquals("Ax1", sb.toString());
639 
640         sb = new StrBuilder("");
641         sb.deleteAll(A_NUMBER_MATCHER);
642         assertEquals("", sb.toString());
643     }
644 
645     @Test
testDeleteFirst_StrMatcher()646     public void testDeleteFirst_StrMatcher() {
647         StrBuilder sb = new StrBuilder("A0xA1A2yA3");
648         sb.deleteFirst((StrMatcher) null);
649         assertEquals("A0xA1A2yA3", sb.toString());
650         sb.deleteFirst(A_NUMBER_MATCHER);
651         assertEquals("xA1A2yA3", sb.toString());
652 
653         sb = new StrBuilder("Ax1");
654         sb.deleteFirst(A_NUMBER_MATCHER);
655         assertEquals("Ax1", sb.toString());
656 
657         sb = new StrBuilder("");
658         sb.deleteFirst(A_NUMBER_MATCHER);
659         assertEquals("", sb.toString());
660     }
661 
662     @Test
testReplace_int_int_String()663     public void testReplace_int_int_String() {
664         final StrBuilder sb = new StrBuilder("abc");
665         sb.replace(0, 1, "d");
666         assertEquals("dbc", sb.toString());
667         sb.replace(0, 1, "aaa");
668         assertEquals("aaabc", sb.toString());
669         sb.replace(0, 3, "");
670         assertEquals("bc", sb.toString());
671         sb.replace(1, 2, null);
672         assertEquals("b", sb.toString());
673         sb.replace(1, 1000, "text");
674         assertEquals("btext", sb.toString());
675         sb.replace(0, 1000, "text");
676         assertEquals("text", sb.toString());
677 
678         final StrBuilder sb1 = new StrBuilder("atext");
679         sb1.replace(1, 1, "ny");
680         assertEquals("anytext", sb1.toString());
681         assertThrows(IndexOutOfBoundsException.class, () -> sb1.replace(2, 1, "anything"));
682 
683         final StrBuilder sb2 = new StrBuilder();
684         assertThrows(IndexOutOfBoundsException.class, () -> sb2.replace(1, 2, "anything"));
685         assertThrows(IndexOutOfBoundsException.class, () -> sb2.replace(-1, 1, "anything"));
686     }
687 
688     @Test
testReplaceAll_char_char()689     public void testReplaceAll_char_char() {
690         final StrBuilder sb = new StrBuilder("abcbccba");
691         sb.replaceAll('x', 'y');
692         assertEquals("abcbccba", sb.toString());
693         sb.replaceAll('a', 'd');
694         assertEquals("dbcbccbd", sb.toString());
695         sb.replaceAll('b', 'e');
696         assertEquals("dececced", sb.toString());
697         sb.replaceAll('c', 'f');
698         assertEquals("defeffed", sb.toString());
699         sb.replaceAll('d', 'd');
700         assertEquals("defeffed", sb.toString());
701     }
702 
703     @Test
testReplaceFirst_char_char()704     public void testReplaceFirst_char_char() {
705         final StrBuilder sb = new StrBuilder("abcbccba");
706         sb.replaceFirst('x', 'y');
707         assertEquals("abcbccba", sb.toString());
708         sb.replaceFirst('a', 'd');
709         assertEquals("dbcbccba", sb.toString());
710         sb.replaceFirst('b', 'e');
711         assertEquals("decbccba", sb.toString());
712         sb.replaceFirst('c', 'f');
713         assertEquals("defbccba", sb.toString());
714         sb.replaceFirst('d', 'd');
715         assertEquals("defbccba", sb.toString());
716     }
717 
718     @Test
testReplaceAll_String_String()719     public void testReplaceAll_String_String() {
720         StrBuilder sb = new StrBuilder("abcbccba");
721         sb.replaceAll((String) null, null);
722         assertEquals("abcbccba", sb.toString());
723         sb.replaceAll((String) null, "anything");
724         assertEquals("abcbccba", sb.toString());
725         sb.replaceAll("", null);
726         assertEquals("abcbccba", sb.toString());
727         sb.replaceAll("", "anything");
728         assertEquals("abcbccba", sb.toString());
729 
730         sb.replaceAll("x", "y");
731         assertEquals("abcbccba", sb.toString());
732         sb.replaceAll("a", "d");
733         assertEquals("dbcbccbd", sb.toString());
734         sb.replaceAll("d", null);
735         assertEquals("bcbccb", sb.toString());
736         sb.replaceAll("cb", "-");
737         assertEquals("b-c-", sb.toString());
738 
739         sb = new StrBuilder("abcba");
740         sb.replaceAll("b", "xbx");
741         assertEquals("axbxcxbxa", sb.toString());
742 
743         sb = new StrBuilder("bb");
744         sb.replaceAll("b", "xbx");
745         assertEquals("xbxxbx", sb.toString());
746     }
747 
748     @Test
testReplaceFirst_String_String()749     public void testReplaceFirst_String_String() {
750         StrBuilder sb = new StrBuilder("abcbccba");
751         sb.replaceFirst((String) null, null);
752         assertEquals("abcbccba", sb.toString());
753         sb.replaceFirst((String) null, "anything");
754         assertEquals("abcbccba", sb.toString());
755         sb.replaceFirst("", null);
756         assertEquals("abcbccba", sb.toString());
757         sb.replaceFirst("", "anything");
758         assertEquals("abcbccba", sb.toString());
759 
760         sb.replaceFirst("x", "y");
761         assertEquals("abcbccba", sb.toString());
762         sb.replaceFirst("a", "d");
763         assertEquals("dbcbccba", sb.toString());
764         sb.replaceFirst("d", null);
765         assertEquals("bcbccba", sb.toString());
766         sb.replaceFirst("cb", "-");
767         assertEquals("b-ccba", sb.toString());
768 
769         sb = new StrBuilder("abcba");
770         sb.replaceFirst("b", "xbx");
771         assertEquals("axbxcba", sb.toString());
772 
773         sb = new StrBuilder("bb");
774         sb.replaceFirst("b", "xbx");
775         assertEquals("xbxb", sb.toString());
776     }
777 
778     @Test
testReplaceAll_StrMatcher_String()779     public void testReplaceAll_StrMatcher_String() {
780         StrBuilder sb = new StrBuilder("abcbccba");
781         sb.replaceAll((StrMatcher) null, null);
782         assertEquals("abcbccba", sb.toString());
783         sb.replaceAll((StrMatcher) null, "anything");
784         assertEquals("abcbccba", sb.toString());
785         sb.replaceAll(StrMatcher.noneMatcher(), null);
786         assertEquals("abcbccba", sb.toString());
787         sb.replaceAll(StrMatcher.noneMatcher(), "anything");
788         assertEquals("abcbccba", sb.toString());
789 
790         sb.replaceAll(StrMatcher.charMatcher('x'), "y");
791         assertEquals("abcbccba", sb.toString());
792         sb.replaceAll(StrMatcher.charMatcher('a'), "d");
793         assertEquals("dbcbccbd", sb.toString());
794         sb.replaceAll(StrMatcher.charMatcher('d'), null);
795         assertEquals("bcbccb", sb.toString());
796         sb.replaceAll(StrMatcher.stringMatcher("cb"), "-");
797         assertEquals("b-c-", sb.toString());
798 
799         sb = new StrBuilder("abcba");
800         sb.replaceAll(StrMatcher.charMatcher('b'), "xbx");
801         assertEquals("axbxcxbxa", sb.toString());
802 
803         sb = new StrBuilder("bb");
804         sb.replaceAll(StrMatcher.charMatcher('b'), "xbx");
805         assertEquals("xbxxbx", sb.toString());
806 
807         sb = new StrBuilder("A1-A2A3-A4");
808         sb.replaceAll(A_NUMBER_MATCHER, "***");
809         assertEquals("***-******-***", sb.toString());
810 
811         sb = new StrBuilder("Dear X, hello X.");
812         sb.replaceAll(StrMatcher.stringMatcher("X"), "012345678901234567");
813         assertEquals("Dear 012345678901234567, hello 012345678901234567.", sb.toString());
814     }
815 
816     @Test
testReplaceFirst_StrMatcher_String()817     public void testReplaceFirst_StrMatcher_String() {
818         StrBuilder sb = new StrBuilder("abcbccba");
819         sb.replaceFirst((StrMatcher) null, null);
820         assertEquals("abcbccba", sb.toString());
821         sb.replaceFirst((StrMatcher) null, "anything");
822         assertEquals("abcbccba", sb.toString());
823         sb.replaceFirst(StrMatcher.noneMatcher(), null);
824         assertEquals("abcbccba", sb.toString());
825         sb.replaceFirst(StrMatcher.noneMatcher(), "anything");
826         assertEquals("abcbccba", sb.toString());
827 
828         sb.replaceFirst(StrMatcher.charMatcher('x'), "y");
829         assertEquals("abcbccba", sb.toString());
830         sb.replaceFirst(StrMatcher.charMatcher('a'), "d");
831         assertEquals("dbcbccba", sb.toString());
832         sb.replaceFirst(StrMatcher.charMatcher('d'), null);
833         assertEquals("bcbccba", sb.toString());
834         sb.replaceFirst(StrMatcher.stringMatcher("cb"), "-");
835         assertEquals("b-ccba", sb.toString());
836 
837         sb = new StrBuilder("abcba");
838         sb.replaceFirst(StrMatcher.charMatcher('b'), "xbx");
839         assertEquals("axbxcba", sb.toString());
840 
841         sb = new StrBuilder("bb");
842         sb.replaceFirst(StrMatcher.charMatcher('b'), "xbx");
843         assertEquals("xbxb", sb.toString());
844 
845         sb = new StrBuilder("A1-A2A3-A4");
846         sb.replaceFirst(A_NUMBER_MATCHER, "***");
847         assertEquals("***-A2A3-A4", sb.toString());
848     }
849 
850     @Test
testReplace_StrMatcher_String_int_int_int_VaryMatcher()851     public void testReplace_StrMatcher_String_int_int_int_VaryMatcher() {
852         StrBuilder sb = new StrBuilder("abcbccba");
853         sb.replace(null, "x", 0, sb.length(), -1);
854         assertEquals("abcbccba", sb.toString());
855 
856         sb.replace(StrMatcher.charMatcher('a'), "x", 0, sb.length(), -1);
857         assertEquals("xbcbccbx", sb.toString());
858 
859         sb.replace(StrMatcher.stringMatcher("cb"), "x", 0, sb.length(), -1);
860         assertEquals("xbxcxx", sb.toString());
861 
862         sb = new StrBuilder("A1-A2A3-A4");
863         sb.replace(A_NUMBER_MATCHER, "***", 0, sb.length(), -1);
864         assertEquals("***-******-***", sb.toString());
865 
866         sb = new StrBuilder();
867         sb.replace(A_NUMBER_MATCHER, "***", 0, sb.length(), -1);
868         assertEquals("", sb.toString());
869     }
870 
871     @Test
testReplace_StrMatcher_String_int_int_int_VaryReplace()872     public void testReplace_StrMatcher_String_int_int_int_VaryReplace() {
873         StrBuilder sb = new StrBuilder("abcbccba");
874         sb.replace(StrMatcher.stringMatcher("cb"), "cb", 0, sb.length(), -1);
875         assertEquals("abcbccba", sb.toString());
876 
877         sb = new StrBuilder("abcbccba");
878         sb.replace(StrMatcher.stringMatcher("cb"), "-", 0, sb.length(), -1);
879         assertEquals("ab-c-a", sb.toString());
880 
881         sb = new StrBuilder("abcbccba");
882         sb.replace(StrMatcher.stringMatcher("cb"), "+++", 0, sb.length(), -1);
883         assertEquals("ab+++c+++a", sb.toString());
884 
885         sb = new StrBuilder("abcbccba");
886         sb.replace(StrMatcher.stringMatcher("cb"), "", 0, sb.length(), -1);
887         assertEquals("abca", sb.toString());
888 
889         sb = new StrBuilder("abcbccba");
890         sb.replace(StrMatcher.stringMatcher("cb"), null, 0, sb.length(), -1);
891         assertEquals("abca", sb.toString());
892     }
893 
894     @Test
testReplace_StrMatcher_String_int_int_int_VaryStartIndex()895     public void testReplace_StrMatcher_String_int_int_int_VaryStartIndex() {
896         StrBuilder sb = new StrBuilder("aaxaaaayaa");
897         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, sb.length(), -1);
898         assertEquals("-x--y-", sb.toString());
899 
900         sb = new StrBuilder("aaxaaaayaa");
901         sb.replace(StrMatcher.stringMatcher("aa"), "-", 1, sb.length(), -1);
902         assertEquals("aax--y-", sb.toString());
903 
904         sb = new StrBuilder("aaxaaaayaa");
905         sb.replace(StrMatcher.stringMatcher("aa"), "-", 2, sb.length(), -1);
906         assertEquals("aax--y-", sb.toString());
907 
908         sb = new StrBuilder("aaxaaaayaa");
909         sb.replace(StrMatcher.stringMatcher("aa"), "-", 3, sb.length(), -1);
910         assertEquals("aax--y-", sb.toString());
911 
912         sb = new StrBuilder("aaxaaaayaa");
913         sb.replace(StrMatcher.stringMatcher("aa"), "-", 4, sb.length(), -1);
914         assertEquals("aaxa-ay-", sb.toString());
915 
916         sb = new StrBuilder("aaxaaaayaa");
917         sb.replace(StrMatcher.stringMatcher("aa"), "-", 5, sb.length(), -1);
918         assertEquals("aaxaa-y-", sb.toString());
919 
920         sb = new StrBuilder("aaxaaaayaa");
921         sb.replace(StrMatcher.stringMatcher("aa"), "-", 6, sb.length(), -1);
922         assertEquals("aaxaaaay-", sb.toString());
923 
924         sb = new StrBuilder("aaxaaaayaa");
925         sb.replace(StrMatcher.stringMatcher("aa"), "-", 7, sb.length(), -1);
926         assertEquals("aaxaaaay-", sb.toString());
927 
928         sb = new StrBuilder("aaxaaaayaa");
929         sb.replace(StrMatcher.stringMatcher("aa"), "-", 8, sb.length(), -1);
930         assertEquals("aaxaaaay-", sb.toString());
931 
932         sb = new StrBuilder("aaxaaaayaa");
933         sb.replace(StrMatcher.stringMatcher("aa"), "-", 9, sb.length(), -1);
934         assertEquals("aaxaaaayaa", sb.toString());
935 
936         sb = new StrBuilder("aaxaaaayaa");
937         sb.replace(StrMatcher.stringMatcher("aa"), "-", 10, sb.length(), -1);
938         assertEquals("aaxaaaayaa", sb.toString());
939 
940         final StrBuilder sb1 = new StrBuilder("aaxaaaayaa");
941         assertThrows(
942                 IndexOutOfBoundsException.class,
943                 () -> sb1.replace(StrMatcher.stringMatcher("aa"), "-", 11, sb1.length(), -1));
944         assertEquals("aaxaaaayaa", sb1.toString());
945 
946         final StrBuilder sb2 = new StrBuilder("aaxaaaayaa");
947         assertThrows(
948                 IndexOutOfBoundsException.class,
949                 () -> sb2.replace(StrMatcher.stringMatcher("aa"), "-", -1, sb2.length(), -1));
950         assertEquals("aaxaaaayaa", sb2.toString());
951     }
952 
953     @Test
testReplace_StrMatcher_String_int_int_int_VaryEndIndex()954     public void testReplace_StrMatcher_String_int_int_int_VaryEndIndex() {
955         StrBuilder sb = new StrBuilder("aaxaaaayaa");
956         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 0, -1);
957         assertEquals("aaxaaaayaa", sb.toString());
958 
959         sb = new StrBuilder("aaxaaaayaa");
960         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 2, -1);
961         assertEquals("-xaaaayaa", sb.toString());
962 
963         sb = new StrBuilder("aaxaaaayaa");
964         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 3, -1);
965         assertEquals("-xaaaayaa", sb.toString());
966 
967         sb = new StrBuilder("aaxaaaayaa");
968         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 4, -1);
969         assertEquals("-xaaaayaa", sb.toString());
970 
971         sb = new StrBuilder("aaxaaaayaa");
972         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 5, -1);
973         assertEquals("-x-aayaa", sb.toString());
974 
975         sb = new StrBuilder("aaxaaaayaa");
976         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 6, -1);
977         assertEquals("-x-aayaa", sb.toString());
978 
979         sb = new StrBuilder("aaxaaaayaa");
980         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 7, -1);
981         assertEquals("-x--yaa", sb.toString());
982 
983         sb = new StrBuilder("aaxaaaayaa");
984         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 8, -1);
985         assertEquals("-x--yaa", sb.toString());
986 
987         sb = new StrBuilder("aaxaaaayaa");
988         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 9, -1);
989         assertEquals("-x--yaa", sb.toString());
990 
991         sb = new StrBuilder("aaxaaaayaa");
992         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, -1);
993         assertEquals("-x--y-", sb.toString());
994 
995         sb = new StrBuilder("aaxaaaayaa");
996         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 1000, -1);
997         assertEquals("-x--y-", sb.toString());
998 
999         final StrBuilder sb1 = new StrBuilder("aaxaaaayaa");
1000         assertThrows(
1001                 IndexOutOfBoundsException.class,
1002                 () -> sb1.replace(StrMatcher.stringMatcher("aa"), "-", 2, 1, -1));
1003         assertEquals("aaxaaaayaa", sb1.toString());
1004     }
1005 
1006     @Test
testReplace_StrMatcher_String_int_int_int_VaryCount()1007     public void testReplace_StrMatcher_String_int_int_int_VaryCount() {
1008         StrBuilder sb = new StrBuilder("aaxaaaayaa");
1009         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, -1);
1010         assertEquals("-x--y-", sb.toString());
1011 
1012         sb = new StrBuilder("aaxaaaayaa");
1013         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 0);
1014         assertEquals("aaxaaaayaa", sb.toString());
1015 
1016         sb = new StrBuilder("aaxaaaayaa");
1017         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 1);
1018         assertEquals("-xaaaayaa", sb.toString());
1019 
1020         sb = new StrBuilder("aaxaaaayaa");
1021         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 2);
1022         assertEquals("-x-aayaa", sb.toString());
1023 
1024         sb = new StrBuilder("aaxaaaayaa");
1025         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 3);
1026         assertEquals("-x--yaa", sb.toString());
1027 
1028         sb = new StrBuilder("aaxaaaayaa");
1029         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 4);
1030         assertEquals("-x--y-", sb.toString());
1031 
1032         sb = new StrBuilder("aaxaaaayaa");
1033         sb.replace(StrMatcher.stringMatcher("aa"), "-", 0, 10, 5);
1034         assertEquals("-x--y-", sb.toString());
1035     }
1036 
1037     @Test
testReverse()1038     public void testReverse() {
1039         final StrBuilder sb = new StrBuilder();
1040         assertEquals("", sb.reverse().toString());
1041 
1042         sb.clear().append(true);
1043         assertEquals("eurt", sb.reverse().toString());
1044         assertEquals("true", sb.reverse().toString());
1045     }
1046 
1047     @Test
testTrim()1048     public void testTrim() {
1049         final StrBuilder sb = new StrBuilder();
1050         assertEquals("", sb.reverse().toString());
1051 
1052         sb.clear().append(" \u0000 ");
1053         assertEquals("", sb.trim().toString());
1054 
1055         sb.clear().append(" \u0000 a b c");
1056         assertEquals("a b c", sb.trim().toString());
1057 
1058         sb.clear().append("a b c \u0000 ");
1059         assertEquals("a b c", sb.trim().toString());
1060 
1061         sb.clear().append(" \u0000 a b c \u0000 ");
1062         assertEquals("a b c", sb.trim().toString());
1063 
1064         sb.clear().append("a b c");
1065         assertEquals("a b c", sb.trim().toString());
1066     }
1067 
1068     @Test
testStartsWith()1069     public void testStartsWith() {
1070         final StrBuilder sb = new StrBuilder();
1071         assertFalse(sb.startsWith("a"));
1072         assertFalse(sb.startsWith(null));
1073         assertTrue(sb.startsWith(""));
1074         sb.append("abc");
1075         assertTrue(sb.startsWith("a"));
1076         assertTrue(sb.startsWith("ab"));
1077         assertTrue(sb.startsWith("abc"));
1078         assertFalse(sb.startsWith("cba"));
1079     }
1080 
1081     @Test
testEndsWith()1082     public void testEndsWith() {
1083         final StrBuilder sb = new StrBuilder();
1084         assertFalse(sb.endsWith("a"));
1085         assertFalse(sb.endsWith("c"));
1086         assertTrue(sb.endsWith(""));
1087         assertFalse(sb.endsWith(null));
1088         sb.append("abc");
1089         assertTrue(sb.endsWith("c"));
1090         assertTrue(sb.endsWith("bc"));
1091         assertTrue(sb.endsWith("abc"));
1092         assertFalse(sb.endsWith("cba"));
1093         assertFalse(sb.endsWith("abcd"));
1094         assertFalse(sb.endsWith(" abc"));
1095         assertFalse(sb.endsWith("abc "));
1096     }
1097 
1098     @Test
testSubSequenceIntInt()1099     public void testSubSequenceIntInt() {
1100        final StrBuilder sb = new StrBuilder ("hello goodbye");
1101        // Start index is negative
1102         assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(-1, 5));
1103 
1104         // End index is negative
1105         assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(2, -1));
1106 
1107         // End index greater than length()
1108         assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(2, sb.length() + 1));
1109 
1110         // Start index greater then end index
1111         assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(3, 2));
1112 
1113         // Normal cases
1114         assertEquals ("hello", sb.subSequence(0, 5));
1115         assertEquals ("hello goodbye".subSequence(0, 6), sb.subSequence(0, 6));
1116         assertEquals ("goodbye", sb.subSequence(6, 13));
1117         assertEquals ("hello goodbye".subSequence(6, 13), sb.subSequence(6, 13));
1118     }
1119 
1120     @Test
testSubstringInt()1121     public void testSubstringInt() {
1122         final StrBuilder sb = new StrBuilder ("hello goodbye");
1123         assertEquals ("goodbye", sb.substring(6));
1124         assertEquals ("hello goodbye".substring(6), sb.substring(6));
1125         assertEquals ("hello goodbye", sb.substring(0));
1126         assertEquals ("hello goodbye".substring(0), sb.substring(0));
1127         assertThrows(IndexOutOfBoundsException.class, () -> sb.substring(-1));
1128 
1129         assertThrows(IndexOutOfBoundsException.class, () -> sb.substring(15));
1130     }
1131 
1132     @Test
testSubstringIntInt()1133     public void testSubstringIntInt() {
1134         final StrBuilder sb = new StrBuilder ("hello goodbye");
1135         assertEquals ("hello", sb.substring(0, 5));
1136         assertEquals ("hello goodbye".substring(0, 6), sb.substring(0, 6));
1137 
1138         assertEquals ("goodbye", sb.substring(6, 13));
1139         assertEquals ("hello goodbye".substring(6, 13), sb.substring(6, 13));
1140 
1141         assertEquals ("goodbye", sb.substring(6, 20));
1142 
1143         assertThrows(IndexOutOfBoundsException.class, () -> sb.substring(-1, 5));
1144         assertThrows(IndexOutOfBoundsException.class, () -> sb.substring(15, 20));
1145     }
1146 
1147     @Test
testMidString()1148     public void testMidString() {
1149         final StrBuilder sb = new StrBuilder("hello goodbye hello");
1150         assertEquals("goodbye", sb.midString(6, 7));
1151         assertEquals("hello", sb.midString(0, 5));
1152         assertEquals("hello", sb.midString(-5, 5));
1153         assertEquals("", sb.midString(0, -1));
1154         assertEquals("", sb.midString(20, 2));
1155         assertEquals("hello", sb.midString(14, 22));
1156     }
1157 
1158     @Test
testRightString()1159     public void testRightString() {
1160         final StrBuilder sb = new StrBuilder("left right");
1161         assertEquals("right", sb.rightString(5));
1162         assertEquals("", sb.rightString(0));
1163         assertEquals("", sb.rightString(-5));
1164         assertEquals("left right", sb.rightString(15));
1165     }
1166 
1167     @Test
testLeftString()1168     public void testLeftString() {
1169         final StrBuilder sb = new StrBuilder("left right");
1170         assertEquals("left", sb.leftString(4));
1171         assertEquals("", sb.leftString(0));
1172         assertEquals("", sb.leftString(-5));
1173         assertEquals("left right", sb.leftString(15));
1174     }
1175 
1176     @Test
testContains_char()1177     public void testContains_char() {
1178         final StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz");
1179         assertTrue(sb.contains('a'));
1180         assertTrue(sb.contains('o'));
1181         assertTrue(sb.contains('z'));
1182         assertFalse(sb.contains('1'));
1183     }
1184 
1185     @Test
testContains_String()1186     public void testContains_String() {
1187         final StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz");
1188         assertTrue(sb.contains("a"));
1189         assertTrue(sb.contains("pq"));
1190         assertTrue(sb.contains("z"));
1191         assertFalse(sb.contains("zyx"));
1192         assertFalse(sb.contains((String) null));
1193     }
1194 
1195     @Test
testContains_StrMatcher()1196     public void testContains_StrMatcher() {
1197         StrBuilder sb = new StrBuilder("abcdefghijklmnopqrstuvwxyz");
1198         assertTrue(sb.contains(StrMatcher.charMatcher('a')));
1199         assertTrue(sb.contains(StrMatcher.stringMatcher("pq")));
1200         assertTrue(sb.contains(StrMatcher.charMatcher('z')));
1201         assertFalse(sb.contains(StrMatcher.stringMatcher("zy")));
1202         assertFalse(sb.contains((StrMatcher) null));
1203 
1204         sb = new StrBuilder();
1205         assertFalse(sb.contains(A_NUMBER_MATCHER));
1206         sb.append("B A1 C");
1207         assertTrue(sb.contains(A_NUMBER_MATCHER));
1208     }
1209 
1210     @Test
testIndexOf_char()1211     public void testIndexOf_char() {
1212         final StrBuilder sb = new StrBuilder("abab");
1213         assertEquals(0, sb.indexOf('a'));
1214 
1215         // should work like String#indexOf
1216         assertEquals("abab".indexOf('a'), sb.indexOf('a'));
1217 
1218         assertEquals(1, sb.indexOf('b'));
1219         assertEquals("abab".indexOf('b'), sb.indexOf('b'));
1220 
1221         assertEquals(-1, sb.indexOf('z'));
1222     }
1223 
1224     @Test
testIndexOf_char_int()1225     public void testIndexOf_char_int() {
1226         StrBuilder sb = new StrBuilder("abab");
1227         assertEquals(0, sb.indexOf('a', -1));
1228         assertEquals(0, sb.indexOf('a', 0));
1229         assertEquals(2, sb.indexOf('a', 1));
1230         assertEquals(-1, sb.indexOf('a', 4));
1231         assertEquals(-1, sb.indexOf('a', 5));
1232 
1233         // should work like String#indexOf
1234         assertEquals("abab".indexOf('a', 1), sb.indexOf('a', 1));
1235 
1236         assertEquals(3, sb.indexOf('b', 2));
1237         assertEquals("abab".indexOf('b', 2), sb.indexOf('b', 2));
1238 
1239         assertEquals(-1, sb.indexOf('z', 2));
1240 
1241         sb = new StrBuilder("xyzabc");
1242         assertEquals(2, sb.indexOf('z', 0));
1243         assertEquals(-1, sb.indexOf('z', 3));
1244     }
1245 
1246     @Test
testLastIndexOf_char()1247     public void testLastIndexOf_char() {
1248         final StrBuilder sb = new StrBuilder("abab");
1249 
1250         assertEquals (2, sb.lastIndexOf('a'));
1251         //should work like String#lastIndexOf
1252         assertEquals ("abab".lastIndexOf('a'), sb.lastIndexOf('a'));
1253 
1254         assertEquals(3, sb.lastIndexOf('b'));
1255         assertEquals ("abab".lastIndexOf('b'), sb.lastIndexOf('b'));
1256 
1257         assertEquals (-1, sb.lastIndexOf('z'));
1258     }
1259 
1260     @Test
testLastIndexOf_char_int()1261     public void testLastIndexOf_char_int() {
1262         StrBuilder sb = new StrBuilder("abab");
1263         assertEquals(-1, sb.lastIndexOf('a', -1));
1264         assertEquals(0, sb.lastIndexOf('a', 0));
1265         assertEquals(0, sb.lastIndexOf('a', 1));
1266 
1267         // should work like String#lastIndexOf
1268         assertEquals("abab".lastIndexOf('a', 1), sb.lastIndexOf('a', 1));
1269 
1270         assertEquals(1, sb.lastIndexOf('b', 2));
1271         assertEquals("abab".lastIndexOf('b', 2), sb.lastIndexOf('b', 2));
1272 
1273         assertEquals(-1, sb.lastIndexOf('z', 2));
1274 
1275         sb = new StrBuilder("xyzabc");
1276         assertEquals(2, sb.lastIndexOf('z', sb.length()));
1277         assertEquals(-1, sb.lastIndexOf('z', 1));
1278     }
1279 
1280     @Test
testIndexOf_String()1281     public void testIndexOf_String() {
1282         final StrBuilder sb = new StrBuilder("abab");
1283 
1284         assertEquals(0, sb.indexOf("a"));
1285         //should work like String#indexOf
1286         assertEquals("abab".indexOf("a"), sb.indexOf("a"));
1287 
1288         assertEquals(0, sb.indexOf("ab"));
1289         //should work like String#indexOf
1290         assertEquals("abab".indexOf("ab"), sb.indexOf("ab"));
1291 
1292         assertEquals(1, sb.indexOf("b"));
1293         assertEquals("abab".indexOf("b"), sb.indexOf("b"));
1294 
1295         assertEquals(1, sb.indexOf("ba"));
1296         assertEquals("abab".indexOf("ba"), sb.indexOf("ba"));
1297 
1298         assertEquals(-1, sb.indexOf("z"));
1299 
1300         assertEquals(-1, sb.indexOf((String) null));
1301     }
1302 
1303     @Test
testIndexOf_String_int()1304     public void testIndexOf_String_int() {
1305         StrBuilder sb = new StrBuilder("abab");
1306         assertEquals(0, sb.indexOf("a", -1));
1307         assertEquals(0, sb.indexOf("a", 0));
1308         assertEquals(2, sb.indexOf("a", 1));
1309         assertEquals(2, sb.indexOf("a", 2));
1310         assertEquals(-1, sb.indexOf("a", 3));
1311         assertEquals(-1, sb.indexOf("a", 4));
1312         assertEquals(-1, sb.indexOf("a", 5));
1313 
1314         assertEquals(-1, sb.indexOf("abcdef", 0));
1315         assertEquals(0, sb.indexOf("", 0));
1316         assertEquals(1, sb.indexOf("", 1));
1317 
1318         //should work like String#indexOf
1319         assertEquals ("abab".indexOf("a", 1), sb.indexOf("a", 1));
1320 
1321         assertEquals(2, sb.indexOf("ab", 1));
1322         //should work like String#indexOf
1323         assertEquals("abab".indexOf("ab", 1), sb.indexOf("ab", 1));
1324 
1325         assertEquals(3, sb.indexOf("b", 2));
1326         assertEquals("abab".indexOf("b", 2), sb.indexOf("b", 2));
1327 
1328         assertEquals(1, sb.indexOf("ba", 1));
1329         assertEquals("abab".indexOf("ba", 2), sb.indexOf("ba", 2));
1330 
1331         assertEquals(-1, sb.indexOf("z", 2));
1332 
1333         sb = new StrBuilder("xyzabc");
1334         assertEquals(2, sb.indexOf("za", 0));
1335         assertEquals(-1, sb.indexOf("za", 3));
1336 
1337         assertEquals(-1, sb.indexOf((String) null, 2));
1338     }
1339 
1340     @Test
testLastIndexOf_String()1341     public void testLastIndexOf_String() {
1342         final StrBuilder sb = new StrBuilder("abab");
1343 
1344         assertEquals(2, sb.lastIndexOf("a"));
1345         //should work like String#lastIndexOf
1346         assertEquals("abab".lastIndexOf("a"), sb.lastIndexOf("a"));
1347 
1348         assertEquals(2, sb.lastIndexOf("ab"));
1349         //should work like String#lastIndexOf
1350         assertEquals("abab".lastIndexOf("ab"), sb.lastIndexOf("ab"));
1351 
1352         assertEquals(3, sb.lastIndexOf("b"));
1353         assertEquals("abab".lastIndexOf("b"), sb.lastIndexOf("b"));
1354 
1355         assertEquals(1, sb.lastIndexOf("ba"));
1356         assertEquals("abab".lastIndexOf("ba"), sb.lastIndexOf("ba"));
1357 
1358         assertEquals(-1, sb.lastIndexOf("z"));
1359 
1360         assertEquals(-1, sb.lastIndexOf((String) null));
1361     }
1362 
1363     @Test
testLastIndexOf_String_int()1364     public void testLastIndexOf_String_int() {
1365         StrBuilder sb = new StrBuilder("abab");
1366         assertEquals(-1, sb.lastIndexOf("a", -1));
1367         assertEquals(0, sb.lastIndexOf("a", 0));
1368         assertEquals(0, sb.lastIndexOf("a", 1));
1369         assertEquals(2, sb.lastIndexOf("a", 2));
1370         assertEquals(2, sb.lastIndexOf("a", 3));
1371         assertEquals(2, sb.lastIndexOf("a", 4));
1372         assertEquals(2, sb.lastIndexOf("a", 5));
1373 
1374         assertEquals(-1, sb.lastIndexOf("abcdef", 3));
1375         assertEquals("abab".lastIndexOf("", 3), sb.lastIndexOf("", 3));
1376         assertEquals("abab".lastIndexOf("", 1), sb.lastIndexOf("", 1));
1377 
1378         //should work like String#lastIndexOf
1379         assertEquals("abab".lastIndexOf("a", 1), sb.lastIndexOf("a", 1));
1380 
1381         assertEquals(0, sb.lastIndexOf("ab", 1));
1382         //should work like String#lastIndexOf
1383         assertEquals("abab".lastIndexOf("ab", 1), sb.lastIndexOf("ab", 1));
1384 
1385         assertEquals(1, sb.lastIndexOf("b", 2));
1386         assertEquals("abab".lastIndexOf("b", 2), sb.lastIndexOf("b", 2));
1387 
1388         assertEquals(1, sb.lastIndexOf("ba", 2));
1389         assertEquals("abab".lastIndexOf("ba", 2), sb.lastIndexOf("ba", 2));
1390 
1391         assertEquals(-1, sb.lastIndexOf("z", 2));
1392 
1393         sb = new StrBuilder("xyzabc");
1394         assertEquals(2, sb.lastIndexOf("za", sb.length()));
1395         assertEquals(-1, sb.lastIndexOf("za", 1));
1396 
1397         assertEquals(-1, sb.lastIndexOf((String) null, 2));
1398     }
1399 
1400     @Test
testIndexOf_StrMatcher()1401     public void testIndexOf_StrMatcher() {
1402         final StrBuilder sb = new StrBuilder();
1403         assertEquals(-1, sb.indexOf((StrMatcher) null));
1404         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a')));
1405 
1406         sb.append("ab bd");
1407         assertEquals(0, sb.indexOf(StrMatcher.charMatcher('a')));
1408         assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b')));
1409         assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher()));
1410         assertEquals(4, sb.indexOf(StrMatcher.charMatcher('d')));
1411         assertEquals(-1, sb.indexOf(StrMatcher.noneMatcher()));
1412         assertEquals(-1, sb.indexOf((StrMatcher) null));
1413 
1414         sb.append(" A1 junction");
1415         assertEquals(6, sb.indexOf(A_NUMBER_MATCHER));
1416     }
1417 
1418     @Test
testIndexOf_StrMatcher_int()1419     public void testIndexOf_StrMatcher_int() {
1420         final StrBuilder sb = new StrBuilder();
1421         assertEquals(-1, sb.indexOf((StrMatcher) null, 2));
1422         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 2));
1423         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 0));
1424 
1425         sb.append("ab bd");
1426         assertEquals(0, sb.indexOf(StrMatcher.charMatcher('a'), -2));
1427         assertEquals(0, sb.indexOf(StrMatcher.charMatcher('a'), 0));
1428         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 2));
1429         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('a'), 20));
1430 
1431         assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'), -1));
1432         assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'), 0));
1433         assertEquals(1, sb.indexOf(StrMatcher.charMatcher('b'), 1));
1434         assertEquals(3, sb.indexOf(StrMatcher.charMatcher('b'), 2));
1435         assertEquals(3, sb.indexOf(StrMatcher.charMatcher('b'), 3));
1436         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('b'), 4));
1437         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('b'), 5));
1438         assertEquals(-1, sb.indexOf(StrMatcher.charMatcher('b'), 6));
1439 
1440         assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher(), -2));
1441         assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher(), 0));
1442         assertEquals(2, sb.indexOf(StrMatcher.spaceMatcher(), 2));
1443         assertEquals(-1, sb.indexOf(StrMatcher.spaceMatcher(), 4));
1444         assertEquals(-1, sb.indexOf(StrMatcher.spaceMatcher(), 20));
1445 
1446         assertEquals(-1, sb.indexOf(StrMatcher.noneMatcher(), 0));
1447         assertEquals(-1, sb.indexOf((StrMatcher) null, 0));
1448 
1449         sb.append(" A1 junction with A2");
1450         assertEquals(6, sb.indexOf(A_NUMBER_MATCHER, 5));
1451         assertEquals(6, sb.indexOf(A_NUMBER_MATCHER, 6));
1452         assertEquals(23, sb.indexOf(A_NUMBER_MATCHER, 7));
1453         assertEquals(23, sb.indexOf(A_NUMBER_MATCHER, 22));
1454         assertEquals(23, sb.indexOf(A_NUMBER_MATCHER, 23));
1455         assertEquals(-1, sb.indexOf(A_NUMBER_MATCHER, 24));
1456     }
1457 
1458     @Test
testLastIndexOf_StrMatcher()1459     public void testLastIndexOf_StrMatcher() {
1460         final StrBuilder sb = new StrBuilder();
1461         assertEquals(-1, sb.lastIndexOf((StrMatcher) null));
1462         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a')));
1463 
1464         sb.append("ab bd");
1465         assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a')));
1466         assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b')));
1467         assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher()));
1468         assertEquals(4, sb.lastIndexOf(StrMatcher.charMatcher('d')));
1469         assertEquals(-1, sb.lastIndexOf(StrMatcher.noneMatcher()));
1470         assertEquals(-1, sb.lastIndexOf((StrMatcher) null));
1471 
1472         sb.append(" A1 junction");
1473         assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER));
1474     }
1475 
1476     @Test
testLastIndexOf_StrMatcher_int()1477     public void testLastIndexOf_StrMatcher_int() {
1478         final StrBuilder sb = new StrBuilder();
1479         assertEquals(-1, sb.lastIndexOf((StrMatcher) null, 2));
1480         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), 2));
1481         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), 0));
1482         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), -1));
1483 
1484         sb.append("ab bd");
1485         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('a'), -2));
1486         assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'), 0));
1487         assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'), 2));
1488         assertEquals(0, sb.lastIndexOf(StrMatcher.charMatcher('a'), 20));
1489 
1490         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('b'), -1));
1491         assertEquals(-1, sb.lastIndexOf(StrMatcher.charMatcher('b'), 0));
1492         assertEquals(1, sb.lastIndexOf(StrMatcher.charMatcher('b'), 1));
1493         assertEquals(1, sb.lastIndexOf(StrMatcher.charMatcher('b'), 2));
1494         assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 3));
1495         assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 4));
1496         assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 5));
1497         assertEquals(3, sb.lastIndexOf(StrMatcher.charMatcher('b'), 6));
1498 
1499         assertEquals(-1, sb.lastIndexOf(StrMatcher.spaceMatcher(), -2));
1500         assertEquals(-1, sb.lastIndexOf(StrMatcher.spaceMatcher(), 0));
1501         assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher(), 2));
1502         assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher(), 4));
1503         assertEquals(2, sb.lastIndexOf(StrMatcher.spaceMatcher(), 20));
1504 
1505         assertEquals(-1, sb.lastIndexOf(StrMatcher.noneMatcher(), 0));
1506         assertEquals(-1, sb.lastIndexOf((StrMatcher) null, 0));
1507 
1508         sb.append(" A1 junction with A2");
1509         assertEquals(-1, sb.lastIndexOf(A_NUMBER_MATCHER, 5));
1510         assertEquals(-1, sb.lastIndexOf(A_NUMBER_MATCHER, 6)); // A matches, 1 is outside bounds
1511         assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER, 7));
1512         assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER, 22));
1513         assertEquals(6, sb.lastIndexOf(A_NUMBER_MATCHER, 23)); // A matches, 2 is outside bounds
1514         assertEquals(23, sb.lastIndexOf(A_NUMBER_MATCHER, 24));
1515     }
1516 
1517     static final StrMatcher A_NUMBER_MATCHER = new StrMatcher() {
1518         @Override
1519         public int isMatch(final char[] buffer, int pos, final int bufferStart, final int bufferEnd) {
1520             if (buffer[pos] == 'A') {
1521                 pos++;
1522                 if (pos < bufferEnd && buffer[pos] >= '0' && buffer[pos] <= '9') {
1523                     return 2;
1524                 }
1525             }
1526             return 0;
1527         }
1528     };
1529 
1530     @Test
testAsTokenizer()1531     public void testAsTokenizer() {
1532         // from Javadoc
1533         final StrBuilder b = new StrBuilder();
1534         b.append("a b ");
1535         final StrTokenizer t = b.asTokenizer();
1536 
1537         final String[] tokens1 = t.getTokenArray();
1538         assertEquals(2, tokens1.length);
1539         assertEquals("a", tokens1[0]);
1540         assertEquals("b", tokens1[1]);
1541         assertEquals(2, t.size());
1542 
1543         b.append("c d ");
1544         final String[] tokens2 = t.getTokenArray();
1545         assertEquals(2, tokens2.length);
1546         assertEquals("a", tokens2[0]);
1547         assertEquals("b", tokens2[1]);
1548         assertEquals(2, t.size());
1549         assertEquals("a", t.next());
1550         assertEquals("b", t.next());
1551 
1552         t.reset();
1553         final String[] tokens3 = t.getTokenArray();
1554         assertEquals(4, tokens3.length);
1555         assertEquals("a", tokens3[0]);
1556         assertEquals("b", tokens3[1]);
1557         assertEquals("c", tokens3[2]);
1558         assertEquals("d", tokens3[3]);
1559         assertEquals(4, t.size());
1560         assertEquals("a", t.next());
1561         assertEquals("b", t.next());
1562         assertEquals("c", t.next());
1563         assertEquals("d", t.next());
1564 
1565         assertEquals("a b c d ", t.getContent());
1566     }
1567 
1568     @Test
testAsReader()1569     public void testAsReader() throws Exception {
1570         final StrBuilder sb = new StrBuilder("some text");
1571         Reader reader = sb.asReader();
1572         assertTrue(reader.ready());
1573         final char[] buf = new char[40];
1574         assertEquals(9, reader.read(buf));
1575         assertEquals("some text", new String(buf, 0, 9));
1576 
1577         assertEquals(-1, reader.read());
1578         assertFalse(reader.ready());
1579         assertEquals(0, reader.skip(2));
1580         assertEquals(0, reader.skip(-1));
1581 
1582         assertTrue(reader.markSupported());
1583         reader = sb.asReader();
1584         assertEquals('s', reader.read());
1585         reader.mark(-1);
1586         char[] array = new char[3];
1587         assertEquals(3, reader.read(array, 0, 3));
1588         assertEquals('o', array[0]);
1589         assertEquals('m', array[1]);
1590         assertEquals('e', array[2]);
1591         reader.reset();
1592         assertEquals(1, reader.read(array, 1, 1));
1593         assertEquals('o', array[0]);
1594         assertEquals('o', array[1]);
1595         assertEquals('e', array[2]);
1596         assertEquals(2, reader.skip(2));
1597         assertEquals(' ', reader.read());
1598 
1599         assertTrue(reader.ready());
1600         reader.close();
1601         assertTrue(reader.ready());
1602 
1603         try (Reader r = sb.asReader()) {
1604             final char[] arr = new char[3];
1605             assertThrows(IndexOutOfBoundsException.class, () -> r.read(arr, -1, 0));
1606             assertThrows(IndexOutOfBoundsException.class, () -> r.read(arr, 0, -1));
1607             assertThrows(IndexOutOfBoundsException.class, () -> r.read(arr, 100, 1));
1608             assertThrows(IndexOutOfBoundsException.class, () -> r.read(arr, 0, 100));
1609             assertThrows(IndexOutOfBoundsException.class, () -> r.read(arr, Integer.MAX_VALUE, Integer.MAX_VALUE));
1610 
1611             assertEquals(0, r.read(arr, 0, 0));
1612             assertEquals(0, arr[0]);
1613             assertEquals(0, arr[1]);
1614             assertEquals(0, arr[2]);
1615 
1616             r.skip(9);
1617             assertEquals(-1, r.read(arr, 0, 1));
1618 
1619             r.reset();
1620             array = new char[30];
1621             assertEquals(9, r.read(array, 0, 30));
1622         }
1623     }
1624 
1625     @Test
testAsWriter()1626     public void testAsWriter() throws Exception {
1627         final StrBuilder sb = new StrBuilder("base");
1628         try (Writer writer = sb.asWriter()) {
1629 
1630             writer.write('l');
1631             assertEquals("basel", sb.toString());
1632 
1633             writer.write(new char[] { 'i', 'n' });
1634             assertEquals("baselin", sb.toString());
1635 
1636             writer.write(new char[] { 'n', 'e', 'r' }, 1, 2);
1637             assertEquals("baseliner", sb.toString());
1638 
1639             writer.write(" rout");
1640             assertEquals("baseliner rout", sb.toString());
1641 
1642             writer.write("ping that server", 1, 3);
1643             assertEquals("baseliner routing", sb.toString());
1644 
1645             writer.flush(); // no effect
1646             assertEquals("baseliner routing", sb.toString());
1647 
1648             writer.close(); // no effect
1649             assertEquals("baseliner routing", sb.toString());
1650 
1651             writer.write(" hi"); // works after close
1652             assertEquals("baseliner routing hi", sb.toString());
1653 
1654             sb.setLength(4); // mix and match
1655             writer.write('d');
1656             assertEquals("based", sb.toString());
1657         }
1658     }
1659 
1660     @Test
testEqualsIgnoreCase()1661     public void testEqualsIgnoreCase() {
1662         final StrBuilder sb1 = new StrBuilder();
1663         final StrBuilder sb2 = new StrBuilder();
1664         assertTrue(sb1.equalsIgnoreCase(sb1));
1665         assertTrue(sb1.equalsIgnoreCase(sb2));
1666         assertTrue(sb2.equalsIgnoreCase(sb2));
1667 
1668         sb1.append("abc");
1669         assertFalse(sb1.equalsIgnoreCase(sb2));
1670 
1671         sb2.append("ABC");
1672         assertTrue(sb1.equalsIgnoreCase(sb2));
1673 
1674         sb2.clear().append("abc");
1675         assertTrue(sb1.equalsIgnoreCase(sb2));
1676         assertTrue(sb1.equalsIgnoreCase(sb1));
1677         assertTrue(sb2.equalsIgnoreCase(sb2));
1678 
1679         sb2.clear().append("aBc");
1680         assertTrue(sb1.equalsIgnoreCase(sb2));
1681     }
1682 
1683     @Test
testEquals()1684     public void testEquals() {
1685         final StrBuilder sb1 = new StrBuilder();
1686         final StrBuilder sb2 = new StrBuilder();
1687         assertTrue(sb1.equals(sb2));
1688         assertTrue(sb1.equals(sb1));
1689         assertTrue(sb2.equals(sb2));
1690         assertEquals(sb1, (Object) sb2);
1691 
1692         sb1.append("abc");
1693         assertFalse(sb1.equals(sb2));
1694         assertNotEquals(sb1, (Object) sb2);
1695 
1696         sb2.append("ABC");
1697         assertFalse(sb1.equals(sb2));
1698         assertNotEquals(sb1, (Object) sb2);
1699 
1700         sb2.clear().append("abc");
1701         assertTrue(sb1.equals(sb2));
1702         assertEquals(sb1, (Object) sb2);
1703 
1704         assertNotEquals(sb1, Integer.valueOf(1));
1705         assertNotEquals("abc", sb1);
1706     }
1707 
1708     @Test
test_LANG_1131_EqualsWithNullStrBuilder()1709     public void test_LANG_1131_EqualsWithNullStrBuilder() {
1710         final StrBuilder sb = new StrBuilder();
1711         final StrBuilder other = null;
1712         assertFalse(sb.equals(other));
1713     }
1714 
1715     @Test
testHashCode()1716     public void testHashCode() {
1717         final StrBuilder sb = new StrBuilder();
1718         final int hc1a = sb.hashCode();
1719         final int hc1b = sb.hashCode();
1720         assertEquals(0, hc1a);
1721         assertEquals(hc1a, hc1b);
1722 
1723         sb.append("abc");
1724         final int hc2a = sb.hashCode();
1725         final int hc2b = sb.hashCode();
1726         assertTrue(hc2a != 0);
1727         assertEquals(hc2a, hc2b);
1728     }
1729 
1730     @Test
testToString()1731     public void testToString() {
1732         final StrBuilder sb = new StrBuilder("abc");
1733         assertEquals("abc", sb.toString());
1734     }
1735 
1736     @Test
testToStringBuffer()1737     public void testToStringBuffer() {
1738         final StrBuilder sb = new StrBuilder();
1739         assertEquals(new StringBuffer().toString(), sb.toStringBuffer().toString());
1740 
1741         sb.append("junit");
1742         assertEquals(new StringBuffer("junit").toString(), sb.toStringBuffer().toString());
1743     }
1744 
1745     @Test
testToStringBuilder()1746     public void testToStringBuilder() {
1747         final StrBuilder sb = new StrBuilder();
1748         assertEquals(new StringBuilder().toString(), sb.toStringBuilder().toString());
1749 
1750         sb.append("junit");
1751         assertEquals(new StringBuilder("junit").toString(), sb.toStringBuilder().toString());
1752     }
1753 
1754     @Test
testLang294()1755     public void testLang294() {
1756         final StrBuilder sb = new StrBuilder("\n%BLAH%\nDo more stuff\neven more stuff\n%BLAH%\n");
1757         sb.deleteAll("\n%BLAH%");
1758         assertEquals("\nDo more stuff\neven more stuff\n", sb.toString());
1759     }
1760 
1761     @Test
testIndexOfLang294()1762     public void testIndexOfLang294() {
1763         final StrBuilder sb = new StrBuilder("onetwothree");
1764         sb.deleteFirst("three");
1765         assertEquals(-1, sb.indexOf("three"));
1766     }
1767 
1768     @Test
testLang295()1769     public void testLang295() {
1770         final StrBuilder sb = new StrBuilder("onetwothree");
1771         sb.deleteFirst("three");
1772         assertFalse(sb.contains('h'), "The contains(char) method is looking beyond the end of the string");
1773         assertEquals(-1, sb.indexOf('h'), "The indexOf(char) method is looking beyond the end of the string");
1774     }
1775 
1776     @Test
testLang412Right()1777     public void testLang412Right() {
1778         final StrBuilder sb = new StrBuilder();
1779         sb.appendFixedWidthPadRight(null, 10, '*');
1780         assertEquals("**********", sb.toString(), "Failed to invoke appendFixedWidthPadRight correctly");
1781     }
1782 
1783     @Test
testLang412Left()1784     public void testLang412Left() {
1785         final StrBuilder sb = new StrBuilder();
1786         sb.appendFixedWidthPadLeft(null, 10, '*');
1787         assertEquals("**********", sb.toString(), "Failed to invoke appendFixedWidthPadLeft correctly");
1788     }
1789 
1790     @Test
testAsBuilder()1791     public void testAsBuilder() {
1792         final StrBuilder sb = new StrBuilder().appendAll("Lorem", " ", "ipsum", " ", "dolor");
1793         assertEquals(sb.toString(), sb.build());
1794     }
1795 
1796     @Test
testAppendCharBuffer()1797     public void testAppendCharBuffer() {
1798         final StrBuilder sb1 = new StrBuilder();
1799         final CharBuffer buf = CharBuffer.allocate(10);
1800         buf.append("0123456789");
1801         buf.flip();
1802         sb1.append(buf);
1803         assertEquals("0123456789", sb1.toString());
1804 
1805         final StrBuilder sb2 = new StrBuilder();
1806         sb2.append(buf, 1, 8);
1807         assertEquals("12345678", sb2.toString());
1808     }
1809 
1810     @Test
testAppendToWriter()1811     public void testAppendToWriter() throws Exception {
1812         final StrBuilder sb = new StrBuilder("1234567890");
1813         final StringWriter writer = new StringWriter();
1814         writer.append("Test ");
1815 
1816         sb.appendTo(writer);
1817 
1818         assertEquals("Test 1234567890", writer.toString());
1819     }
1820 
1821     @Test
testAppendToStringBuilder()1822     public void testAppendToStringBuilder() throws Exception {
1823         final StrBuilder sb = new StrBuilder("1234567890");
1824         final StringBuilder builder = new StringBuilder("Test ");
1825 
1826         sb.appendTo(builder);
1827 
1828         assertEquals("Test 1234567890", builder.toString());
1829     }
1830 
1831     @Test
testAppendToStringBuffer()1832     public void testAppendToStringBuffer() throws Exception {
1833         final StrBuilder sb = new StrBuilder("1234567890");
1834         final StringBuffer buffer = new StringBuffer("Test ");
1835 
1836         sb.appendTo(buffer);
1837 
1838         assertEquals("Test 1234567890", buffer.toString());
1839     }
1840 
1841     @Test
testAppendToCharBuffer()1842     public void testAppendToCharBuffer() throws Exception {
1843         final StrBuilder sb = new StrBuilder("1234567890");
1844         final String text = "Test ";
1845         final CharBuffer buffer = CharBuffer.allocate(sb.size() + text.length());
1846         buffer.put(text);
1847 
1848         sb.appendTo(buffer);
1849 
1850         buffer.flip();
1851         assertEquals("Test 1234567890", buffer.toString());
1852     }
1853 }
1854