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