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