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