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.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
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
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();
262 assertEquals("baseliner routing", sb.toString());
263
264 writer.close();
265 assertEquals("baseliner routing", sb.toString());
266
267 writer.write(" hi");
268 assertEquals("baseliner routing hi", sb.toString());
269
270 sb.setLength(4);
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
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
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
846 assertEquals("abab".indexOf("a"), sb.indexOf("a"));
847
848 assertEquals(0, sb.indexOf("ab"));
849
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
879 assertEquals ("abab".indexOf("a", 1), sb.indexOf("a", 1));
880
881 assertEquals(2, sb.indexOf("ab", 1));
882
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
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
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
1046 assertEquals("abab".lastIndexOf("a"), sb.lastIndexOf("a"));
1047
1048 assertEquals(2, sb.lastIndexOf("ab"));
1049
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
1079 assertEquals("abab".lastIndexOf("a", 1), sb.lastIndexOf("a", 1));
1080
1081 assertEquals(0, sb.lastIndexOf("ab", 1));
1082
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));
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));
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);
1683 assertEquals("He", sb.toString());
1684 sb.setLength(2);
1685 assertEquals("He", sb.toString());
1686 sb.setLength(3);
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
1721 assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(-1, 5));
1722
1723
1724 assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(2, -1));
1725
1726
1727 assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(2, sb.length() + 1));
1728
1729
1730 assertThrows(IndexOutOfBoundsException.class, () -> sb.subSequence(3, 2));
1731
1732
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);
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 }