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.junit.jupiter.api.Assertions.assertEquals;
21 import static org.junit.jupiter.api.Assertions.assertThrows;
22 import static org.junit.jupiter.api.Assertions.fail;
23
24 import java.text.DecimalFormatSymbols;
25 import java.util.Arrays;
26 import java.util.Collection;
27 import java.util.Collections;
28 import java.util.Iterator;
29
30 import org.apache.commons.lang3.ArrayUtils;
31 import org.junit.jupiter.api.Test;
32
33
34
35
36
37
38 @Deprecated
39 public class StrBuilderAppendInsertTest {
40
41
42 private static final String SEP = System.lineSeparator();
43
44
45 private static final Object FOO = new Object() {
46 @Override
47 public String toString() {
48 return "foo";
49 }
50 };
51
52 @Test
53 public void testAppend_Boolean() {
54 final StrBuilder sb = new StrBuilder();
55 sb.append(true);
56 assertEquals("true", sb.toString());
57
58 sb.append(false);
59 assertEquals("truefalse", sb.toString());
60
61 sb.append('!');
62 assertEquals("truefalse!", sb.toString());
63 }
64
65 @Test
66 public void testAppend_CharArray() {
67 StrBuilder sb = new StrBuilder();
68 sb.setNullText("NULL").append((char[]) null);
69 assertEquals("NULL", sb.toString());
70
71 sb = new StrBuilder();
72 sb.append(ArrayUtils.EMPTY_CHAR_ARRAY);
73 assertEquals("", sb.toString());
74
75 sb.append(new char[] { 'f', 'o', 'o' });
76 assertEquals("foo", sb.toString());
77 }
78
79 @Test
80 public void testAppend_CharArray_int_int() {
81 StrBuilder sb = new StrBuilder();
82 sb.setNullText("NULL").append((char[]) null, 0, 1);
83 assertEquals("NULL", sb.toString());
84
85 sb = new StrBuilder();
86 sb.append(new char[] { 'f', 'o', 'o' }, 0, 3);
87 assertEquals("foo", sb.toString());
88
89 try {
90 sb.append(new char[] { 'b', 'a', 'r' }, -1, 1);
91 fail("append(char[], -1,) expected IndexOutOfBoundsException");
92 } catch (final IndexOutOfBoundsException e) {
93
94 }
95
96 try {
97 sb.append(new char[] { 'b', 'a', 'r' }, 3, 1);
98 fail("append(char[], 3,) expected IndexOutOfBoundsException");
99 } catch (final IndexOutOfBoundsException e) {
100
101 }
102
103 try {
104 sb.append(new char[] { 'b', 'a', 'r' }, 1, -1);
105 fail("append(char[],, -1) expected IndexOutOfBoundsException");
106 } catch (final IndexOutOfBoundsException e) {
107
108 }
109
110 try {
111 sb.append(new char[] { 'b', 'a', 'r' }, 1, 3);
112 fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
113 } catch (final IndexOutOfBoundsException e) {
114
115 }
116
117 try {
118 sb.append(new char[] { 'b', 'a', 'r' }, -1, 3);
119 fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
120 } catch (final IndexOutOfBoundsException e) {
121
122 }
123
124 try {
125 sb.append(new char[] { 'b', 'a', 'r' }, 4, 0);
126 fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
127 } catch (final IndexOutOfBoundsException e) {
128
129 }
130
131 sb.append(new char[] { 'b', 'a', 'r' }, 3, 0);
132 assertEquals("foo", sb.toString());
133
134 sb.append(new char[] { 'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f' }, 3, 3);
135 assertEquals("foobar", sb.toString());
136 }
137
138 @Test
139 public void testAppend_FormattedString() {
140 StrBuilder sb;
141
142 sb = new StrBuilder();
143 sb.append("Hi", (Object[]) null);
144 assertEquals("Hi", sb.toString());
145
146 sb = new StrBuilder();
147 sb.append("Hi", "Alice");
148 assertEquals("Hi", sb.toString());
149
150 sb = new StrBuilder();
151 sb.append("Hi %s", "Alice");
152 assertEquals("Hi Alice", sb.toString());
153
154 sb = new StrBuilder();
155 sb.append("Hi %s %,d", "Alice", 5000);
156
157 final char groupingSeparator = DecimalFormatSymbols.getInstance().getGroupingSeparator();
158 final String expected = "Hi Alice 5" + groupingSeparator + "000";
159 assertEquals(expected, sb.toString());
160 }
161
162 @Test
163 public void testAppend_Object() {
164 final StrBuilder sb = new StrBuilder();
165 sb.appendNull();
166 assertEquals("", sb.toString());
167
168 sb.append((Object) null);
169 assertEquals("", sb.toString());
170
171 sb.append(FOO);
172 assertEquals("foo", sb.toString());
173
174 sb.append((StringBuffer) null);
175 assertEquals("foo", sb.toString());
176
177 sb.append(new StringBuffer("baz"));
178 assertEquals("foobaz", sb.toString());
179
180 sb.append(new StrBuilder("yes"));
181 assertEquals("foobazyes", sb.toString());
182
183 sb.append((CharSequence) "Seq");
184 assertEquals("foobazyesSeq", sb.toString());
185
186 sb.append(new StringBuilder("bld"));
187 assertEquals("foobazyesSeqbld", sb.toString());
188 }
189
190 @Test
191 public void testAppend_PrimitiveNumber() {
192 final StrBuilder sb = new StrBuilder();
193 sb.append(0);
194 assertEquals("0", sb.toString());
195
196 sb.append(1L);
197 assertEquals("01", sb.toString());
198
199 sb.append(2.3f);
200 assertEquals("012.3", sb.toString());
201
202 sb.append(4.5d);
203 assertEquals("012.34.5", sb.toString());
204 }
205
206 @Test
207 public void testAppend_StrBuilder() {
208 StrBuilder sb = new StrBuilder();
209 sb.setNullText("NULL").append((StrBuilder) null);
210 assertEquals("NULL", sb.toString());
211
212 sb = new StrBuilder();
213 sb.append(new StrBuilder("foo"));
214 assertEquals("foo", sb.toString());
215
216 sb.append(new StrBuilder(""));
217 assertEquals("foo", sb.toString());
218
219 sb.append(new StrBuilder("bar"));
220 assertEquals("foobar", sb.toString());
221 }
222
223 @Test
224 public void testAppend_StrBuilder_int_int() {
225 StrBuilder sb = new StrBuilder();
226 sb.setNullText("NULL").append((StrBuilder) null, 0, 1);
227 assertEquals("NULL", sb.toString());
228
229 sb = new StrBuilder();
230 sb.append(new StrBuilder("foo"), 0, 3);
231 assertEquals("foo", sb.toString());
232
233 try {
234 sb.append(new StrBuilder("bar"), -1, 1);
235 fail("append(char[], -1,) expected IndexOutOfBoundsException");
236 } catch (final IndexOutOfBoundsException e) {
237
238 }
239
240 try {
241 sb.append(new StrBuilder("bar"), 3, 1);
242 fail("append(char[], 3,) expected IndexOutOfBoundsException");
243 } catch (final IndexOutOfBoundsException e) {
244
245 }
246
247 try {
248 sb.append(new StrBuilder("bar"), 1, -1);
249 fail("append(char[],, -1) expected IndexOutOfBoundsException");
250 } catch (final IndexOutOfBoundsException e) {
251
252 }
253
254 try {
255 sb.append(new StrBuilder("bar"), 1, 3);
256 fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
257 } catch (final IndexOutOfBoundsException e) {
258
259 }
260
261 try {
262 sb.append(new StrBuilder("bar"), -1, 3);
263 fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
264 } catch (final IndexOutOfBoundsException e) {
265
266 }
267
268 try {
269 sb.append(new StrBuilder("bar"), 4, 0);
270 fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
271 } catch (final IndexOutOfBoundsException e) {
272
273 }
274
275 sb.append(new StrBuilder("bar"), 3, 0);
276 assertEquals("foo", sb.toString());
277
278 sb.append(new StrBuilder("abcbardef"), 3, 3);
279 assertEquals("foobar", sb.toString());
280 }
281
282 @Test
283 public void testAppend_String() {
284 StrBuilder sb = new StrBuilder();
285 sb.setNullText("NULL").append((String) null);
286 assertEquals("NULL", sb.toString());
287
288 sb = new StrBuilder();
289 sb.append("foo");
290 assertEquals("foo", sb.toString());
291
292 sb.append("");
293 assertEquals("foo", sb.toString());
294
295 sb.append("bar");
296 assertEquals("foobar", sb.toString());
297 }
298
299 @Test
300 public void testAppend_String_int_int() {
301 StrBuilder sb = new StrBuilder();
302 sb.setNullText("NULL").append((String) null, 0, 1);
303 assertEquals("NULL", sb.toString());
304
305 sb = new StrBuilder();
306 sb.append("foo", 0, 3);
307 assertEquals("foo", sb.toString());
308
309 try {
310 sb.append("bar", -1, 1);
311 fail("append(char[], -1,) expected IndexOutOfBoundsException");
312 } catch (final IndexOutOfBoundsException e) {
313
314 }
315
316 try {
317 sb.append("bar", 3, 1);
318 fail("append(char[], 3,) expected IndexOutOfBoundsException");
319 } catch (final IndexOutOfBoundsException e) {
320
321 }
322
323 try {
324 sb.append("bar", 1, -1);
325 fail("append(char[],, -1) expected IndexOutOfBoundsException");
326 } catch (final IndexOutOfBoundsException e) {
327
328 }
329
330 try {
331 sb.append("bar", 1, 3);
332 fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
333 } catch (final IndexOutOfBoundsException e) {
334
335 }
336
337 try {
338 sb.append("bar", -1, 3);
339 fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
340 } catch (final IndexOutOfBoundsException e) {
341
342 }
343
344 try {
345 sb.append("bar", 4, 0);
346 fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
347 } catch (final IndexOutOfBoundsException e) {
348
349 }
350
351 sb.append("bar", 3, 0);
352 assertEquals("foo", sb.toString());
353
354 sb.append("abcbardef", 3, 3);
355 assertEquals("foobar", sb.toString());
356
357 sb.append((CharSequence) "abcbardef", 4, 3);
358 assertEquals("foobarard", sb.toString());
359 }
360
361 @Test
362 public void testAppend_StringBuffer() {
363 StrBuilder sb = new StrBuilder();
364 sb.setNullText("NULL").append((StringBuffer) null);
365 assertEquals("NULL", sb.toString());
366
367 sb = new StrBuilder();
368 sb.append(new StringBuffer("foo"));
369 assertEquals("foo", sb.toString());
370
371 sb.append(new StringBuffer(""));
372 assertEquals("foo", sb.toString());
373
374 sb.append(new StringBuffer("bar"));
375 assertEquals("foobar", sb.toString());
376 }
377
378 @Test
379 public void testAppend_StringBuffer_int_int() {
380 StrBuilder sb = new StrBuilder();
381 sb.setNullText("NULL").append((StringBuffer) null, 0, 1);
382 assertEquals("NULL", sb.toString());
383
384 sb = new StrBuilder();
385 sb.append(new StringBuffer("foo"), 0, 3);
386 assertEquals("foo", sb.toString());
387
388 try {
389 sb.append(new StringBuffer("bar"), -1, 1);
390 fail("append(char[], -1,) expected IndexOutOfBoundsException");
391 } catch (final IndexOutOfBoundsException e) {
392
393 }
394
395 try {
396 sb.append(new StringBuffer("bar"), 3, 1);
397 fail("append(char[], 3,) expected IndexOutOfBoundsException");
398 } catch (final IndexOutOfBoundsException e) {
399
400 }
401
402 try {
403 sb.append(new StringBuffer("bar"), 1, -1);
404 fail("append(char[],, -1) expected IndexOutOfBoundsException");
405 } catch (final IndexOutOfBoundsException e) {
406
407 }
408
409 try {
410 sb.append(new StringBuffer("bar"), 1, 3);
411 fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
412 } catch (final IndexOutOfBoundsException e) {
413
414 }
415
416 try {
417 sb.append(new StringBuffer("bar"), -1, 3);
418 fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
419 } catch (final IndexOutOfBoundsException e) {
420
421 }
422
423 try {
424 sb.append(new StringBuffer("bar"), 4, 0);
425 fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
426 } catch (final IndexOutOfBoundsException e) {
427
428 }
429
430 sb.append(new StringBuffer("bar"), 3, 0);
431 assertEquals("foo", sb.toString());
432
433 sb.append(new StringBuffer("abcbardef"), 3, 3);
434 assertEquals("foobar", sb.toString());
435 }
436
437 @Test
438 public void testAppend_StringBuilder() {
439 StrBuilder sb = new StrBuilder();
440 sb.setNullText("NULL").append((String) null);
441 assertEquals("NULL", sb.toString());
442
443 sb = new StrBuilder();
444 sb.append(new StringBuilder("foo"));
445 assertEquals("foo", sb.toString());
446
447 sb.append(new StringBuilder(""));
448 assertEquals("foo", sb.toString());
449
450 sb.append(new StringBuilder("bar"));
451 assertEquals("foobar", sb.toString());
452 }
453
454 @Test
455 public void testAppend_StringBuilder_int_int() {
456 StrBuilder sb = new StrBuilder();
457 sb.setNullText("NULL").append((String) null, 0, 1);
458 assertEquals("NULL", sb.toString());
459
460 sb = new StrBuilder();
461 sb.append(new StringBuilder("foo"), 0, 3);
462 assertEquals("foo", sb.toString());
463
464 try {
465 sb.append(new StringBuilder("bar"), -1, 1);
466 fail("append(StringBuilder, -1,) expected IndexOutOfBoundsException");
467 } catch (final IndexOutOfBoundsException e) {
468
469 }
470
471 try {
472 sb.append(new StringBuilder("bar"), 3, 1);
473 fail("append(StringBuilder, 3,) expected IndexOutOfBoundsException");
474 } catch (final IndexOutOfBoundsException e) {
475
476 }
477
478 try {
479 sb.append(new StringBuilder("bar"), 1, -1);
480 fail("append(StringBuilder,, -1) expected IndexOutOfBoundsException");
481 } catch (final IndexOutOfBoundsException e) {
482
483 }
484
485 try {
486 sb.append(new StringBuilder("bar"), 1, 3);
487 fail("append(StringBuilder, 1, 3) expected IndexOutOfBoundsException");
488 } catch (final IndexOutOfBoundsException e) {
489
490 }
491
492 try {
493 sb.append(new StringBuilder("bar"), -1, 3);
494 fail("append(StringBuilder, -1, 3) expected IndexOutOfBoundsException");
495 } catch (final IndexOutOfBoundsException e) {
496
497 }
498
499 try {
500 sb.append(new StringBuilder("bar"), 4, 0);
501 fail("append(StringBuilder, 4, 0) expected IndexOutOfBoundsException");
502 } catch (final IndexOutOfBoundsException e) {
503
504 }
505
506 sb.append(new StringBuilder("bar"), 3, 0);
507 assertEquals("foo", sb.toString());
508
509 sb.append(new StringBuilder("abcbardef"), 3, 3);
510 assertEquals("foobar", sb.toString());
511
512 sb.append(new StringBuilder("abcbardef"), 4, 3);
513 assertEquals("foobarard", sb.toString());
514 }
515
516 @Test
517 public void testAppendAll_Array() {
518 final StrBuilder sb = new StrBuilder();
519 sb.appendAll((Object[]) null);
520 assertEquals("", sb.toString());
521
522 sb.clear();
523 sb.appendAll();
524 assertEquals("", sb.toString());
525
526 sb.clear();
527 sb.appendAll("foo", "bar", "baz");
528 assertEquals("foobarbaz", sb.toString());
529
530 sb.clear();
531 sb.appendAll("foo", "bar", "baz");
532 assertEquals("foobarbaz", sb.toString());
533 }
534
535 @Test
536 public void testAppendAll_Collection() {
537 final StrBuilder sb = new StrBuilder();
538 sb.appendAll((Collection<?>) null);
539 assertEquals("", sb.toString());
540
541 sb.clear();
542 sb.appendAll(Collections.EMPTY_LIST);
543 assertEquals("", sb.toString());
544
545 sb.clear();
546 sb.appendAll(Arrays.asList("foo", "bar", "baz"));
547 assertEquals("foobarbaz", sb.toString());
548 }
549
550 @Test
551 public void testAppendAll_Iterator() {
552 final StrBuilder sb = new StrBuilder();
553 sb.appendAll((Iterator<?>) null);
554 assertEquals("", sb.toString());
555
556 sb.clear();
557 sb.appendAll(Collections.EMPTY_LIST.iterator());
558 assertEquals("", sb.toString());
559
560 sb.clear();
561 sb.appendAll(Arrays.asList("foo", "bar", "baz").iterator());
562 assertEquals("foobarbaz", sb.toString());
563 }
564
565 @Test
566 public void testAppendFixedWidthPadLeft() {
567 final StrBuilder sb = new StrBuilder();
568 sb.appendFixedWidthPadLeft("foo", -1, '-');
569 assertEquals("", sb.toString());
570
571 sb.clear();
572 sb.appendFixedWidthPadLeft("foo", 0, '-');
573 assertEquals("", sb.toString());
574
575 sb.clear();
576 sb.appendFixedWidthPadLeft("foo", 1, '-');
577 assertEquals("o", sb.toString());
578
579 sb.clear();
580 sb.appendFixedWidthPadLeft("foo", 2, '-');
581 assertEquals("oo", sb.toString());
582
583 sb.clear();
584 sb.appendFixedWidthPadLeft("foo", 3, '-');
585 assertEquals("foo", sb.toString());
586
587 sb.clear();
588 sb.appendFixedWidthPadLeft("foo", 4, '-');
589 assertEquals("-foo", sb.toString());
590
591 sb.clear();
592 sb.appendFixedWidthPadLeft("foo", 10, '-');
593 assertEquals(10, sb.length());
594
595 assertEquals("-------foo", sb.toString());
596
597 sb.clear();
598 sb.setNullText("null");
599 sb.appendFixedWidthPadLeft(null, 5, '-');
600 assertEquals("-null", sb.toString());
601 }
602
603 @Test
604 public void testAppendFixedWidthPadLeft_int() {
605 final StrBuilder sb = new StrBuilder();
606 sb.appendFixedWidthPadLeft(123, -1, '-');
607 assertEquals("", sb.toString());
608
609 sb.clear();
610 sb.appendFixedWidthPadLeft(123, 0, '-');
611 assertEquals("", sb.toString());
612
613 sb.clear();
614 sb.appendFixedWidthPadLeft(123, 1, '-');
615 assertEquals("3", sb.toString());
616
617 sb.clear();
618 sb.appendFixedWidthPadLeft(123, 2, '-');
619 assertEquals("23", sb.toString());
620
621 sb.clear();
622 sb.appendFixedWidthPadLeft(123, 3, '-');
623 assertEquals("123", sb.toString());
624
625 sb.clear();
626 sb.appendFixedWidthPadLeft(123, 4, '-');
627 assertEquals("-123", sb.toString());
628
629 sb.clear();
630 sb.appendFixedWidthPadLeft(123, 10, '-');
631 assertEquals(10, sb.length());
632
633 assertEquals("-------123", sb.toString());
634 }
635
636 @Test
637 public void testAppendFixedWidthPadRight() {
638 final StrBuilder sb = new StrBuilder();
639 sb.appendFixedWidthPadRight("foo", -1, '-');
640 assertEquals("", sb.toString());
641
642 sb.clear();
643 sb.appendFixedWidthPadRight("foo", 0, '-');
644 assertEquals("", sb.toString());
645
646 sb.clear();
647 sb.appendFixedWidthPadRight("foo", 1, '-');
648 assertEquals("f", sb.toString());
649
650 sb.clear();
651 sb.appendFixedWidthPadRight("foo", 2, '-');
652 assertEquals("fo", sb.toString());
653
654 sb.clear();
655 sb.appendFixedWidthPadRight("foo", 3, '-');
656 assertEquals("foo", sb.toString());
657
658 sb.clear();
659 sb.appendFixedWidthPadRight("foo", 4, '-');
660 assertEquals("foo-", sb.toString());
661
662 sb.clear();
663 sb.appendFixedWidthPadRight("foo", 10, '-');
664 assertEquals(10, sb.length());
665
666 assertEquals("foo-------", sb.toString());
667
668 sb.clear();
669 sb.setNullText("null");
670 sb.appendFixedWidthPadRight(null, 5, '-');
671 assertEquals("null-", sb.toString());
672 }
673
674 @Test
675 public void testAppendFixedWidthPadRight_int() {
676 final StrBuilder sb = new StrBuilder();
677 sb.appendFixedWidthPadRight(123, -1, '-');
678 assertEquals("", sb.toString());
679
680 sb.clear();
681 sb.appendFixedWidthPadRight(123, 0, '-');
682 assertEquals("", sb.toString());
683
684 sb.clear();
685 sb.appendFixedWidthPadRight(123, 1, '-');
686 assertEquals("1", sb.toString());
687
688 sb.clear();
689 sb.appendFixedWidthPadRight(123, 2, '-');
690 assertEquals("12", sb.toString());
691
692 sb.clear();
693 sb.appendFixedWidthPadRight(123, 3, '-');
694 assertEquals("123", sb.toString());
695
696 sb.clear();
697 sb.appendFixedWidthPadRight(123, 4, '-');
698 assertEquals("123-", sb.toString());
699
700 sb.clear();
701 sb.appendFixedWidthPadRight(123, 10, '-');
702 assertEquals(10, sb.length());
703
704 assertEquals("123-------", sb.toString());
705 }
706
707 @Test
708 public void testAppendln_Boolean() {
709 final StrBuilder sb = new StrBuilder();
710 sb.appendln(true);
711 assertEquals("true" + SEP, sb.toString());
712
713 sb.clear();
714 sb.appendln(false);
715 assertEquals("false" + SEP, sb.toString());
716 }
717
718 @Test
719 public void testAppendln_CharArray() {
720 final int[] count = new int[2];
721 final StrBuilder sb = new StrBuilder() {
722 private static final long serialVersionUID = 1L;
723
724 @Override
725 public StrBuilder append(final char[] str) {
726 count[0]++;
727 return super.append(str);
728 }
729
730 @Override
731 public StrBuilder appendNewLine() {
732 count[1]++;
733 return super.appendNewLine();
734 }
735 };
736 sb.appendln("foo".toCharArray());
737 assertEquals("foo" + SEP, sb.toString());
738 assertEquals(1, count[0]);
739 assertEquals(1, count[1]);
740 }
741
742 @Test
743 public void testAppendln_CharArray_int_int() {
744 final int[] count = new int[2];
745 final StrBuilder sb = new StrBuilder() {
746 private static final long serialVersionUID = 1L;
747
748 @Override
749 public StrBuilder append(final char[] str, final int startIndex, final int length) {
750 count[0]++;
751 return super.append(str, startIndex, length);
752 }
753
754 @Override
755 public StrBuilder appendNewLine() {
756 count[1]++;
757 return super.appendNewLine();
758 }
759 };
760 sb.appendln("foo".toCharArray(), 0, 3);
761 assertEquals("foo" + SEP, sb.toString());
762 assertEquals(1, count[0]);
763 assertEquals(1, count[1]);
764 }
765
766 @Test
767 public void testAppendln_FormattedString() {
768 final int[] count = new int[2];
769 final StrBuilder sb = new StrBuilder() {
770 private static final long serialVersionUID = 1L;
771
772 @Override
773 public StrBuilder append(final String str) {
774 count[0]++;
775 return super.append(str);
776 }
777
778 @Override
779 public StrBuilder appendNewLine() {
780 count[1]++;
781 return super.appendNewLine();
782 }
783 };
784 sb.appendln("Hello %s", "Alice");
785 assertEquals("Hello Alice" + SEP, sb.toString());
786 assertEquals(2, count[0]);
787 assertEquals(1, count[1]);
788 }
789
790 @Test
791 public void testAppendln_Object() {
792 final StrBuilder sb = new StrBuilder();
793 sb.appendln((Object) null);
794 assertEquals("" + SEP, sb.toString());
795
796 sb.appendln(FOO);
797 assertEquals(SEP + "foo" + SEP, sb.toString());
798
799 sb.appendln(Integer.valueOf(6));
800 assertEquals(SEP + "foo" + SEP + "6" + SEP, sb.toString());
801 }
802
803 @Test
804 public void testAppendln_PrimitiveNumber() {
805 final StrBuilder sb = new StrBuilder();
806 sb.appendln(0);
807 assertEquals("0" + SEP, sb.toString());
808
809 sb.clear();
810 sb.appendln(1L);
811 assertEquals("1" + SEP, sb.toString());
812
813 sb.clear();
814 sb.appendln(2.3f);
815 assertEquals("2.3" + SEP, sb.toString());
816
817 sb.clear();
818 sb.appendln(4.5d);
819 assertEquals("4.5" + SEP, sb.toString());
820 }
821
822 @Test
823 public void testAppendln_StrBuilder() {
824 final int[] count = new int[2];
825 final StrBuilder sb = new StrBuilder() {
826 private static final long serialVersionUID = 1L;
827
828 @Override
829 public StrBuilder append(final StrBuilder str) {
830 count[0]++;
831 return super.append(str);
832 }
833
834 @Override
835 public StrBuilder appendNewLine() {
836 count[1]++;
837 return super.appendNewLine();
838 }
839 };
840 sb.appendln(new StrBuilder("foo"));
841 assertEquals("foo" + SEP, sb.toString());
842 assertEquals(1, count[0]);
843 assertEquals(1, count[1]);
844 }
845
846 @Test
847 public void testAppendln_StrBuilder_int_int() {
848 final int[] count = new int[2];
849 final StrBuilder sb = new StrBuilder() {
850 private static final long serialVersionUID = 1L;
851
852 @Override
853 public StrBuilder append(final StrBuilder str, final int startIndex, final int length) {
854 count[0]++;
855 return super.append(str, startIndex, length);
856 }
857
858 @Override
859 public StrBuilder appendNewLine() {
860 count[1]++;
861 return super.appendNewLine();
862 }
863 };
864 sb.appendln(new StrBuilder("foo"), 0, 3);
865 assertEquals("foo" + SEP, sb.toString());
866 assertEquals(1, count[0]);
867 assertEquals(1, count[1]);
868 }
869
870 @Test
871 public void testAppendln_String() {
872 final int[] count = new int[2];
873 final StrBuilder sb = new StrBuilder() {
874 private static final long serialVersionUID = 1L;
875
876 @Override
877 public StrBuilder append(final String str) {
878 count[0]++;
879 return super.append(str);
880 }
881
882 @Override
883 public StrBuilder appendNewLine() {
884 count[1]++;
885 return super.appendNewLine();
886 }
887 };
888 sb.appendln("foo");
889 assertEquals("foo" + SEP, sb.toString());
890 assertEquals(2, count[0]);
891 assertEquals(1, count[1]);
892 }
893
894 @Test
895 public void testAppendln_String_int_int() {
896 final int[] count = new int[2];
897 final StrBuilder sb = new StrBuilder() {
898 private static final long serialVersionUID = 1L;
899
900 @Override
901 public StrBuilder append(final String str, final int startIndex, final int length) {
902 count[0]++;
903 return super.append(str, startIndex, length);
904 }
905
906 @Override
907 public StrBuilder appendNewLine() {
908 count[1]++;
909 return super.appendNewLine();
910 }
911 };
912 sb.appendln("foo", 0, 3);
913 assertEquals("foo" + SEP, sb.toString());
914 assertEquals(1, count[0]);
915 assertEquals(1, count[1]);
916 }
917
918 @Test
919 public void testAppendln_StringBuffer() {
920 final int[] count = new int[2];
921 final StrBuilder sb = new StrBuilder() {
922 private static final long serialVersionUID = 1L;
923
924 @Override
925 public StrBuilder append(final StringBuffer str) {
926 count[0]++;
927 return super.append(str);
928 }
929
930 @Override
931 public StrBuilder appendNewLine() {
932 count[1]++;
933 return super.appendNewLine();
934 }
935 };
936 sb.appendln(new StringBuffer("foo"));
937 assertEquals("foo" + SEP, sb.toString());
938 assertEquals(1, count[0]);
939 assertEquals(1, count[1]);
940 }
941
942 @Test
943 public void testAppendln_StringBuffer_int_int() {
944 final int[] count = new int[2];
945 final StrBuilder sb = new StrBuilder() {
946 private static final long serialVersionUID = 1L;
947
948 @Override
949 public StrBuilder append(final StringBuffer str, final int startIndex, final int length) {
950 count[0]++;
951 return super.append(str, startIndex, length);
952 }
953
954 @Override
955 public StrBuilder appendNewLine() {
956 count[1]++;
957 return super.appendNewLine();
958 }
959 };
960 sb.appendln(new StringBuffer("foo"), 0, 3);
961 assertEquals("foo" + SEP, sb.toString());
962 assertEquals(1, count[0]);
963 assertEquals(1, count[1]);
964 }
965
966 @Test
967 public void testAppendln_StringBuilder() {
968 final int[] count = new int[2];
969 final StrBuilder sb = new StrBuilder() {
970 private static final long serialVersionUID = 1L;
971
972 @Override
973 public StrBuilder append(final StringBuilder str) {
974 count[0]++;
975 return super.append(str);
976 }
977
978 @Override
979 public StrBuilder appendNewLine() {
980 count[1]++;
981 return super.appendNewLine();
982 }
983 };
984 sb.appendln(new StringBuilder("foo"));
985 assertEquals("foo" + SEP, sb.toString());
986 assertEquals(1, count[0]);
987 assertEquals(1, count[1]);
988 }
989
990 @Test
991 public void testAppendln_StringBuilder_int_int() {
992 final int[] count = new int[2];
993 final StrBuilder sb = new StrBuilder() {
994 private static final long serialVersionUID = 1L;
995
996 @Override
997 public StrBuilder append(final StringBuilder str, final int startIndex, final int length) {
998 count[0]++;
999 return super.append(str, startIndex, length);
1000 }
1001
1002 @Override
1003 public StrBuilder appendNewLine() {
1004 count[1]++;
1005 return super.appendNewLine();
1006 }
1007 };
1008 sb.appendln(new StringBuilder("foo"), 0, 3);
1009 assertEquals("foo" + SEP, sb.toString());
1010 assertEquals(1, count[0]);
1011 assertEquals(1, count[1]);
1012 }
1013
1014 @Test
1015 public void testAppendNewLine() {
1016 StrBuilder sb = new StrBuilder("---");
1017 sb.appendNewLine().append("+++");
1018 assertEquals("---" + SEP + "+++", sb.toString());
1019
1020 sb = new StrBuilder("---");
1021 sb.setNewLineText("#").appendNewLine().setNewLineText(null).appendNewLine();
1022 assertEquals("---#" + SEP, sb.toString());
1023 }
1024
1025 @Test
1026 public void testAppendPadding() {
1027 final StrBuilder sb = new StrBuilder();
1028 sb.append("foo");
1029 assertEquals("foo", sb.toString());
1030
1031 sb.appendPadding(-1, '-');
1032 assertEquals("foo", sb.toString());
1033
1034 sb.appendPadding(0, '-');
1035 assertEquals("foo", sb.toString());
1036
1037 sb.appendPadding(1, '-');
1038 assertEquals("foo-", sb.toString());
1039
1040 sb.appendPadding(16, '-');
1041 assertEquals(20, sb.length());
1042
1043 assertEquals("foo-----------------", sb.toString());
1044 }
1045
1046 @Test
1047 public void testAppendSeparator_char() {
1048 final StrBuilder sb = new StrBuilder();
1049 sb.appendSeparator(',');
1050 assertEquals("", sb.toString());
1051 sb.append("foo");
1052 assertEquals("foo", sb.toString());
1053 sb.appendSeparator(',');
1054 assertEquals("foo,", sb.toString());
1055 }
1056
1057 @Test
1058 public void testAppendSeparator_char_char() {
1059 final StrBuilder sb = new StrBuilder();
1060 final char startSeparator = ':';
1061 final char standardSeparator = ',';
1062 final String foo = "foo";
1063 sb.appendSeparator(standardSeparator, startSeparator);
1064 assertEquals(String.valueOf(startSeparator), sb.toString());
1065 sb.append(foo);
1066 assertEquals(String.valueOf(startSeparator) + foo, sb.toString());
1067 sb.appendSeparator(standardSeparator, startSeparator);
1068 assertEquals(String.valueOf(startSeparator) + foo + standardSeparator, sb.toString());
1069 }
1070
1071 @Test
1072 public void testAppendSeparator_char_int() {
1073 final StrBuilder sb = new StrBuilder();
1074 sb.appendSeparator(',', 0);
1075 assertEquals("", sb.toString());
1076 sb.append("foo");
1077 assertEquals("foo", sb.toString());
1078 sb.appendSeparator(',', 1);
1079 assertEquals("foo,", sb.toString());
1080
1081 sb.appendSeparator(',', -1);
1082 assertEquals("foo,", sb.toString());
1083 }
1084
1085 @Test
1086 public void testAppendSeparator_String() {
1087 final StrBuilder sb = new StrBuilder();
1088 sb.appendSeparator(",");
1089 assertEquals("", sb.toString());
1090 sb.append("foo");
1091 assertEquals("foo", sb.toString());
1092 sb.appendSeparator(",");
1093 assertEquals("foo,", sb.toString());
1094 }
1095
1096 @Test
1097 public void testAppendSeparator_String_int() {
1098 final StrBuilder sb = new StrBuilder();
1099 sb.appendSeparator(",", 0);
1100 assertEquals("", sb.toString());
1101 sb.append("foo");
1102 assertEquals("foo", sb.toString());
1103 sb.appendSeparator(",", 1);
1104 assertEquals("foo,", sb.toString());
1105
1106 sb.appendSeparator(",", -1);
1107 assertEquals("foo,", sb.toString());
1108 }
1109
1110 @Test
1111 public void testAppendSeparator_String_String() {
1112 final StrBuilder sb = new StrBuilder();
1113 final String startSeparator = "order by ";
1114 final String standardSeparator = ",";
1115 final String foo = "foo";
1116 sb.appendSeparator(null, null);
1117 assertEquals("", sb.toString());
1118 sb.appendSeparator(standardSeparator, null);
1119 assertEquals("", sb.toString());
1120 sb.appendSeparator(standardSeparator, startSeparator);
1121 assertEquals(startSeparator, sb.toString());
1122 sb.appendSeparator(null, null);
1123 assertEquals(startSeparator, sb.toString());
1124 sb.appendSeparator(null, startSeparator);
1125 assertEquals(startSeparator, sb.toString());
1126 sb.append(foo);
1127 assertEquals(startSeparator + foo, sb.toString());
1128 sb.appendSeparator(standardSeparator, startSeparator);
1129 assertEquals(startSeparator + foo + standardSeparator, sb.toString());
1130 }
1131
1132 @Test
1133 public void testAppendWithNullText() {
1134 final StrBuilder sb = new StrBuilder();
1135 sb.setNullText("NULL");
1136 assertEquals("", sb.toString());
1137
1138 sb.appendNull();
1139 assertEquals("NULL", sb.toString());
1140
1141 sb.append((Object) null);
1142 assertEquals("NULLNULL", sb.toString());
1143
1144 sb.append(FOO);
1145 assertEquals("NULLNULLfoo", sb.toString());
1146
1147 sb.append((String) null);
1148 assertEquals("NULLNULLfooNULL", sb.toString());
1149
1150 sb.append("");
1151 assertEquals("NULLNULLfooNULL", sb.toString());
1152
1153 sb.append("bar");
1154 assertEquals("NULLNULLfooNULLbar", sb.toString());
1155
1156 sb.append((StringBuffer) null);
1157 assertEquals("NULLNULLfooNULLbarNULL", sb.toString());
1158
1159 sb.append(new StringBuffer("baz"));
1160 assertEquals("NULLNULLfooNULLbarNULLbaz", sb.toString());
1161 }
1162
1163 @Test
1164 public void testAppendWithSeparators_Array() {
1165 final StrBuilder sb = new StrBuilder();
1166 sb.appendWithSeparators((Object[]) null, ",");
1167 assertEquals("", sb.toString());
1168
1169 sb.clear();
1170 sb.appendWithSeparators(ArrayUtils.EMPTY_OBJECT_ARRAY, ",");
1171 assertEquals("", sb.toString());
1172
1173 sb.clear();
1174 sb.appendWithSeparators(new Object[] { "foo", "bar", "baz" }, ",");
1175 assertEquals("foo,bar,baz", sb.toString());
1176
1177 sb.clear();
1178 sb.appendWithSeparators(new Object[] { "foo", "bar", "baz" }, null);
1179 assertEquals("foobarbaz", sb.toString());
1180
1181 sb.clear();
1182 sb.appendWithSeparators(new Object[] { "foo", null, "baz" }, ",");
1183 assertEquals("foo,,baz", sb.toString());
1184 }
1185
1186 @Test
1187 public void testAppendWithSeparators_Collection() {
1188 final StrBuilder sb = new StrBuilder();
1189 sb.appendWithSeparators((Collection<?>) null, ",");
1190 assertEquals("", sb.toString());
1191
1192 sb.clear();
1193 sb.appendWithSeparators(Collections.EMPTY_LIST, ",");
1194 assertEquals("", sb.toString());
1195
1196 sb.clear();
1197 sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), ",");
1198 assertEquals("foo,bar,baz", sb.toString());
1199
1200 sb.clear();
1201 sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), null);
1202 assertEquals("foobarbaz", sb.toString());
1203
1204 sb.clear();
1205 sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
1206 assertEquals("foo,,baz", sb.toString());
1207 }
1208
1209 @Test
1210 public void testAppendWithSeparators_Iterator() {
1211 final StrBuilder sb = new StrBuilder();
1212 sb.appendWithSeparators((Iterator<?>) null, ",");
1213 assertEquals("", sb.toString());
1214
1215 sb.clear();
1216 sb.appendWithSeparators(Collections.EMPTY_LIST.iterator(), ",");
1217 assertEquals("", sb.toString());
1218
1219 sb.clear();
1220 sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), ",");
1221 assertEquals("foo,bar,baz", sb.toString());
1222
1223 sb.clear();
1224 sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), null);
1225 assertEquals("foobarbaz", sb.toString());
1226
1227 sb.clear();
1228 sb.appendWithSeparators(Arrays.asList("foo", null, "baz").iterator(), ",");
1229 assertEquals("foo,,baz", sb.toString());
1230 }
1231
1232 @Test
1233 public void testAppendWithSeparatorsWithNullText() {
1234 final StrBuilder sb = new StrBuilder();
1235 sb.setNullText("null");
1236 sb.appendWithSeparators(new Object[] { "foo", null, "baz" }, ",");
1237 assertEquals("foo,null,baz", sb.toString());
1238
1239 sb.clear();
1240 sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
1241 assertEquals("foo,null,baz", sb.toString());
1242 }
1243
1244 @Test
1245 public void testInsert() {
1246
1247 final StrBuilder sb = new StrBuilder();
1248 sb.append("barbaz");
1249 assertEquals("barbaz", sb.toString());
1250
1251 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, FOO));
1252
1253 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, FOO));
1254
1255 sb.insert(0, (Object) null);
1256 assertEquals("barbaz", sb.toString());
1257
1258 sb.insert(0, FOO);
1259 assertEquals("foobarbaz", sb.toString());
1260
1261 sb.clear();
1262 sb.append("barbaz");
1263 assertEquals("barbaz", sb.toString());
1264
1265 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, "foo"));
1266
1267 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, "foo"));
1268
1269 sb.insert(0, (String) null);
1270 assertEquals("barbaz", sb.toString());
1271
1272 sb.insert(0, "foo");
1273 assertEquals("foobarbaz", sb.toString());
1274
1275 sb.clear();
1276 sb.append("barbaz");
1277 assertEquals("barbaz", sb.toString());
1278
1279 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[] { 'f', 'o', 'o' }));
1280
1281 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[] { 'f', 'o', 'o' }));
1282
1283 sb.insert(0, (char[]) null);
1284 assertEquals("barbaz", sb.toString());
1285
1286 sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY);
1287 assertEquals("barbaz", sb.toString());
1288
1289 sb.insert(0, new char[] { 'f', 'o', 'o' });
1290 assertEquals("foobarbaz", sb.toString());
1291
1292 sb.clear();
1293 sb.append("barbaz");
1294 assertEquals("barbaz", sb.toString());
1295
1296 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3));
1297
1298 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3));
1299
1300 sb.insert(0, (char[]) null, 0, 0);
1301 assertEquals("barbaz", sb.toString());
1302
1303 sb.insert(0, ArrayUtils.EMPTY_CHAR_ARRAY, 0, 0);
1304 assertEquals("barbaz", sb.toString());
1305
1306 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, -1, 3));
1307
1308 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 10, 3));
1309
1310 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, -1));
1311
1312 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, 10));
1313
1314 sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, 0);
1315 assertEquals("barbaz", sb.toString());
1316
1317 sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3);
1318 assertEquals("foobarbaz", sb.toString());
1319
1320 sb.clear();
1321 sb.append("barbaz");
1322 assertEquals("barbaz", sb.toString());
1323
1324 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, true));
1325
1326 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, true));
1327
1328 sb.insert(0, true);
1329 assertEquals("truebarbaz", sb.toString());
1330
1331 sb.insert(0, false);
1332 assertEquals("falsetruebarbaz", sb.toString());
1333
1334 sb.clear();
1335 sb.append("barbaz");
1336 assertEquals("barbaz", sb.toString());
1337
1338 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, '!'));
1339
1340 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, '!'));
1341
1342 sb.insert(0, '!');
1343 assertEquals("!barbaz", sb.toString());
1344
1345 sb.clear();
1346 sb.append("barbaz");
1347 assertEquals("barbaz", sb.toString());
1348
1349 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 0));
1350
1351 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 0));
1352
1353 sb.insert(0, '0');
1354 assertEquals("0barbaz", sb.toString());
1355
1356 sb.clear();
1357 sb.append("barbaz");
1358 assertEquals("barbaz", sb.toString());
1359
1360 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 1L));
1361
1362 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 1L));
1363
1364 sb.insert(0, 1L);
1365 assertEquals("1barbaz", sb.toString());
1366
1367 sb.clear();
1368 sb.append("barbaz");
1369 assertEquals("barbaz", sb.toString());
1370
1371 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 2.3F));
1372
1373 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 2.3F));
1374
1375 sb.insert(0, 2.3F);
1376 assertEquals("2.3barbaz", sb.toString());
1377
1378 sb.clear();
1379 sb.append("barbaz");
1380 assertEquals("barbaz", sb.toString());
1381
1382 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, 4.5D));
1383
1384 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, 4.5D));
1385
1386 sb.insert(0, 4.5D);
1387 assertEquals("4.5barbaz", sb.toString());
1388 }
1389
1390 @Test
1391 public void testInsertWithNullText() {
1392 final StrBuilder sb = new StrBuilder();
1393 sb.setNullText("null");
1394 sb.append("barbaz");
1395 assertEquals("barbaz", sb.toString());
1396
1397 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, FOO));
1398
1399 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, FOO));
1400
1401 sb.insert(0, (Object) null);
1402 assertEquals("nullbarbaz", sb.toString());
1403
1404 sb.insert(0, FOO);
1405 assertEquals("foonullbarbaz", sb.toString());
1406
1407 sb.clear();
1408 sb.append("barbaz");
1409 assertEquals("barbaz", sb.toString());
1410
1411 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(-1, "foo"));
1412
1413 assertThrows(IndexOutOfBoundsException.class, () -> sb.insert(7, "foo"));
1414
1415 sb.insert(0, (String) null);
1416 assertEquals("nullbarbaz", sb.toString());
1417
1418 sb.insert(0, "foo");
1419 assertEquals("foonullbarbaz", sb.toString());
1420
1421 sb.insert(0, (char[]) null);
1422 assertEquals("nullfoonullbarbaz", sb.toString());
1423
1424 sb.insert(0, (char[]) null, 0, 0);
1425 assertEquals("nullnullfoonullbarbaz", sb.toString());
1426 }
1427
1428
1429
1430
1431
1432
1433
1434
1435