View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.lang3.text;
19  
20  import static org.apache.commons.lang3.LangAssertions.assertIndexOutOfBoundsException;
21  import static org.junit.jupiter.api.Assertions.assertEquals;
22  
23  import java.text.DecimalFormatSymbols;
24  import java.util.Arrays;
25  import java.util.Collection;
26  import java.util.Collections;
27  import java.util.Iterator;
28  
29  import org.apache.commons.lang3.AbstractLangTest;
30  import org.junit.jupiter.api.Test;
31  
32  /**
33   * Tests for {@link org.apache.commons.lang3.text.StrBuilder}.
34   */
35  @Deprecated
36  class StrBuilderAppendInsertTest extends AbstractLangTest {
37  
38      /** The system line separator. */
39      private static final String SEP = System.lineSeparator();
40  
41      /** Test subclass of Object, with a toString method. */
42      private static final Object FOO = new Object() {
43          @Override
44          public String toString() {
45              return "foo";
46          }
47      };
48  
49      @Test
50      void testAppend_Boolean() {
51          final StrBuilder sb = new StrBuilder();
52          sb.append(true);
53          assertEquals("true", sb.toString());
54  
55          sb.append(false);
56          assertEquals("truefalse", sb.toString());
57  
58          sb.append('!');
59          assertEquals("truefalse!", sb.toString());
60      }
61  
62      @Test
63      void testAppend_CharArray() {
64          StrBuilder sb = new StrBuilder();
65          sb.setNullText("NULL").append((char[]) null);
66          assertEquals("NULL", sb.toString());
67  
68          sb = new StrBuilder();
69          sb.append(new char[0]);
70          assertEquals("", sb.toString());
71  
72          sb.append(new char[]{'f', 'o', 'o'});
73          assertEquals("foo", sb.toString());
74      }
75  
76      @Test
77      void testAppend_CharArray_int_int() {
78          StrBuilder sb = new StrBuilder();
79          sb.setNullText("NULL").append((char[]) null, 0, 1);
80          assertEquals("NULL", sb.toString());
81          sb = new StrBuilder();
82          sb.append(new char[] { 'f', 'o', 'o' }, 0, 3);
83          assertEquals("foo", sb.toString());
84          final StrBuilder sb1 = sb;
85          assertIndexOutOfBoundsException(() -> sb1.append(new char[] { 'b', 'a', 'r' }, -1, 1),
86                  "append(char[], -1,) expected IndexOutOfBoundsException");
87          assertIndexOutOfBoundsException(() -> sb1.append(new char[] { 'b', 'a', 'r' }, 3, 1),
88                  "append(char[], 3,) expected IndexOutOfBoundsException");
89          assertIndexOutOfBoundsException(() -> sb1.append(new char[] { 'b', 'a', 'r' }, 1, -1),
90                  "append(char[],, -1) expected IndexOutOfBoundsException");
91          assertIndexOutOfBoundsException(() -> sb1.append(new char[] { 'b', 'a', 'r' }, 1, 3),
92                  "append(char[], 1, 3) expected IndexOutOfBoundsException");
93          assertIndexOutOfBoundsException(() -> sb1.append(new char[] { 'b', 'a', 'r' }, -1, 3),
94                  "append(char[], -1, 3) expected IndexOutOfBoundsException");
95          assertIndexOutOfBoundsException(() -> sb1.append(new char[] { 'b', 'a', 'r' }, 4, 0),
96                  "append(char[], 4, 0) expected IndexOutOfBoundsException");
97          sb.append(new char[] { 'b', 'a', 'r' }, 3, 0);
98          assertEquals("foo", sb.toString());
99          sb.append(new char[] { 'a', 'b', 'c', 'b', 'a', 'r', 'd', 'e', 'f' }, 3, 3);
100         assertEquals("foobar", sb.toString());
101     }
102 
103     @Test
104     void testAppend_FormattedString() {
105         StrBuilder sb;
106 
107         sb = new StrBuilder();
108         sb.append("Hi", (Object[]) null);
109         assertEquals("Hi", sb.toString());
110 
111         sb = new StrBuilder();
112         sb.append("Hi", "Alice");
113         assertEquals("Hi", sb.toString());
114 
115         sb = new StrBuilder();
116         sb.append("Hi %s", "Alice");
117         assertEquals("Hi Alice", sb.toString());
118 
119         sb = new StrBuilder();
120         sb.append("Hi %s %,d", "Alice", 5000);
121         // group separator depends on system locale
122         final char groupingSeparator = DecimalFormatSymbols.getInstance().getGroupingSeparator();
123         final String expected = "Hi Alice 5" + groupingSeparator + "000";
124         assertEquals(expected, sb.toString());
125     }
126 
127     @Test
128     void testAppend_Object() {
129         final StrBuilder sb = new StrBuilder();
130         sb.appendNull();
131         assertEquals("", sb.toString());
132 
133         sb.append((Object) null);
134         assertEquals("", sb.toString());
135 
136         sb.append(FOO);
137         assertEquals("foo", sb.toString());
138 
139         sb.append((StringBuffer) null);
140         assertEquals("foo", sb.toString());
141 
142         sb.append(new StringBuffer("baz"));
143         assertEquals("foobaz", sb.toString());
144 
145         sb.append(new StrBuilder("yes"));
146         assertEquals("foobazyes", sb.toString());
147 
148         sb.append((CharSequence) "Seq");
149         assertEquals("foobazyesSeq", sb.toString());
150 
151         sb.append(new StringBuilder("bld")); // Check it supports StringBuilder
152         assertEquals("foobazyesSeqbld", sb.toString());
153     }
154 
155     @Test
156     void testAppend_PrimitiveNumber() {
157         final StrBuilder sb = new StrBuilder();
158         sb.append(0);
159         assertEquals("0", sb.toString());
160 
161         sb.append(1L);
162         assertEquals("01", sb.toString());
163 
164         sb.append(2.3f);
165         assertEquals("012.3", sb.toString());
166 
167         sb.append(4.5d);
168         assertEquals("012.34.5", sb.toString());
169     }
170 
171     @Test
172     void testAppend_StrBuilder() {
173         StrBuilder sb = new StrBuilder();
174         sb.setNullText("NULL").append((StrBuilder) null);
175         assertEquals("NULL", sb.toString());
176 
177         sb = new StrBuilder();
178         sb.append(new StrBuilder("foo"));
179         assertEquals("foo", sb.toString());
180 
181         sb.append(new StrBuilder(""));
182         assertEquals("foo", sb.toString());
183 
184         sb.append(new StrBuilder("bar"));
185         assertEquals("foobar", sb.toString());
186     }
187 
188     @Test
189     void testAppend_StrBuilder_int_int() {
190         StrBuilder sb = new StrBuilder();
191         sb.setNullText("NULL").append((StrBuilder) null, 0, 1);
192         assertEquals("NULL", sb.toString());
193         sb = new StrBuilder();
194         sb.append(new StrBuilder("foo"), 0, 3);
195         assertEquals("foo", sb.toString());
196         final StrBuilder sb1 = sb;
197         assertIndexOutOfBoundsException(() -> sb1.append(new StrBuilder("bar"), -1, 1), "append(char[], -1,) expected IndexOutOfBoundsException");
198         assertIndexOutOfBoundsException(() -> sb1.append(new StrBuilder("bar"), 3, 1), "append(char[], 3,) expected IndexOutOfBoundsException");
199         assertIndexOutOfBoundsException(() -> sb1.append(new StrBuilder("bar"), 1, -1), "append(char[],, -1) expected IndexOutOfBoundsException");
200         assertIndexOutOfBoundsException(() -> sb1.append(new StrBuilder("bar"), 1, 3), "append(char[], 1, 3) expected IndexOutOfBoundsException");
201         assertIndexOutOfBoundsException(() -> sb1.append(new StrBuilder("bar"), -1, 3),
202                 "append(char[], -1, 3) expected IndexOutOfBoundsException");
203         assertIndexOutOfBoundsException(() -> sb1.append(new StrBuilder("bar"), 4, 0), "append(char[], 4, 0) expected IndexOutOfBoundsException");
204         sb.append(new StrBuilder("bar"), 3, 0);
205         assertEquals("foo", sb.toString());
206         sb.append(new StrBuilder("abcbardef"), 3, 3);
207         assertEquals("foobar", sb.toString());
208     }
209 
210     @Test
211     void testAppend_String() {
212         StrBuilder sb = new StrBuilder();
213         sb.setNullText("NULL").append((String) null);
214         assertEquals("NULL", sb.toString());
215 
216         sb = new StrBuilder();
217         sb.append("foo");
218         assertEquals("foo", sb.toString());
219 
220         sb.append("");
221         assertEquals("foo", sb.toString());
222 
223         sb.append("bar");
224         assertEquals("foobar", sb.toString());
225     }
226 
227     @Test
228     void testAppend_String_int_int() {
229         StrBuilder sb = new StrBuilder();
230         sb.setNullText("NULL").append((String) null, 0, 1);
231         assertEquals("NULL", sb.toString());
232         sb = new StrBuilder();
233         sb.append("foo", 0, 3);
234         assertEquals("foo", sb.toString());
235         final StrBuilder sb1 = sb;
236         assertIndexOutOfBoundsException(() -> sb1.append("bar", -1, 1), "append(char[], -1,) expected IndexOutOfBoundsException");
237         assertIndexOutOfBoundsException(() -> sb1.append("bar", 3, 1), "append(char[], 3,) expected IndexOutOfBoundsException");
238         assertIndexOutOfBoundsException(() -> sb1.append("bar", 1, -1), "append(char[],, -1) expected IndexOutOfBoundsException");
239         assertIndexOutOfBoundsException(() -> sb1.append("bar", 1, 3), "append(char[], 1, 3) expected IndexOutOfBoundsException");
240         assertIndexOutOfBoundsException(() -> sb1.append("bar", -1, 3), "append(char[], -1, 3) expected IndexOutOfBoundsException");
241         assertIndexOutOfBoundsException(() -> sb1.append("bar", 4, 0), "append(char[], 4, 0) expected IndexOutOfBoundsException");
242         sb.append("bar", 3, 0);
243         assertEquals("foo", sb.toString());
244         sb.append("abcbardef", 3, 3);
245         assertEquals("foobar", sb.toString());
246         sb.append((CharSequence) "abcbardef", 4, 3);
247         assertEquals("foobarard", sb.toString());
248     }
249 
250     @Test
251     void testAppend_StringBuffer() {
252         StrBuilder sb = new StrBuilder();
253         sb.setNullText("NULL").append((StringBuffer) null);
254         assertEquals("NULL", sb.toString());
255 
256         sb = new StrBuilder();
257         sb.append(new StringBuffer("foo"));
258         assertEquals("foo", sb.toString());
259 
260         sb.append(new StringBuffer(""));
261         assertEquals("foo", sb.toString());
262 
263         sb.append(new StringBuffer("bar"));
264         assertEquals("foobar", sb.toString());
265     }
266 
267     @Test
268     void testAppend_StringBuffer_int_int() {
269         StrBuilder sb = new StrBuilder();
270         sb.setNullText("NULL").append((StringBuffer) null, 0, 1);
271         assertEquals("NULL", sb.toString());
272         sb = new StrBuilder();
273         sb.append(new StringBuffer("foo"), 0, 3);
274         assertEquals("foo", sb.toString());
275         final StrBuilder sb1 = sb;
276         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuffer("bar"), -1, 1),
277                 "append(char[], -1,) expected IndexOutOfBoundsException");
278         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuffer("bar"), 3, 1), "append(char[], 3,) expected IndexOutOfBoundsException");
279         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuffer("bar"), 1, -1),
280                 "append(char[],, -1) expected IndexOutOfBoundsException");
281         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuffer("bar"), 1, 3),
282                 "append(char[], 1, 3) expected IndexOutOfBoundsException");
283         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuffer("bar"), -1, 3),
284                 "append(char[], -1, 3) expected IndexOutOfBoundsException");
285         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuffer("bar"), 4, 0),
286                 "append(char[], 4, 0) expected IndexOutOfBoundsException");
287         sb.append(new StringBuffer("bar"), 3, 0);
288         assertEquals("foo", sb.toString());
289         sb.append(new StringBuffer("abcbardef"), 3, 3);
290         assertEquals("foobar", sb.toString());
291     }
292 
293     @Test
294     void testAppend_StringBuilder() {
295         StrBuilder sb = new StrBuilder();
296         sb.setNullText("NULL").append((String) null);
297         assertEquals("NULL", sb.toString());
298 
299         sb = new StrBuilder();
300         sb.append(new StringBuilder("foo"));
301         assertEquals("foo", sb.toString());
302 
303         sb.append(new StringBuilder(""));
304         assertEquals("foo", sb.toString());
305 
306         sb.append(new StringBuilder("bar"));
307         assertEquals("foobar", sb.toString());
308     }
309 
310     @Test
311     void testAppend_StringBuilder_int_int() {
312         StrBuilder sb = new StrBuilder();
313         sb.setNullText("NULL").append((String) null, 0, 1);
314         assertEquals("NULL", sb.toString());
315         sb = new StrBuilder();
316         sb.append(new StringBuilder("foo"), 0, 3);
317         assertEquals("foo", sb.toString());
318         final StrBuilder sb1 = sb;
319         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuilder("bar"), -1, 1),
320                 "append(StringBuilder, -1,) expected IndexOutOfBoundsException");
321         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuilder("bar"), 3, 1),
322                 "append(StringBuilder, 3,) expected IndexOutOfBoundsException");
323         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuilder("bar"), 1, -1),
324                 "append(StringBuilder,, -1) expected IndexOutOfBoundsException");
325         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuilder("bar"), 1, 3),
326                 "append(StringBuilder, 1, 3) expected IndexOutOfBoundsException");
327         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuilder("bar"), -1, 3),
328                 "append(StringBuilder, -1, 3) expected IndexOutOfBoundsException");
329         assertIndexOutOfBoundsException(() -> sb1.append(new StringBuilder("bar"), 4, 0),
330                 "append(StringBuilder, 4, 0) expected IndexOutOfBoundsException");
331         sb.append(new StringBuilder("bar"), 3, 0);
332         assertEquals("foo", sb.toString());
333         sb.append(new StringBuilder("abcbardef"), 3, 3);
334         assertEquals("foobar", sb.toString());
335         sb.append(new StringBuilder("abcbardef"), 4, 3);
336         assertEquals("foobarard", sb.toString());
337     }
338 
339     @Test
340     void testAppendAll_Array() {
341         final StrBuilder sb = new StrBuilder();
342         sb.appendAll((Object[]) null);
343         assertEquals("", sb.toString());
344 
345         sb.clear();
346         sb.appendAll();
347         assertEquals("", sb.toString());
348 
349         sb.clear();
350         sb.appendAll("foo", "bar", "baz");
351         assertEquals("foobarbaz", sb.toString());
352 
353         sb.clear();
354         sb.appendAll("foo", "bar", "baz");
355         assertEquals("foobarbaz", sb.toString());
356     }
357 
358     @Test
359     void testAppendAll_Collection() {
360         final StrBuilder sb = new StrBuilder();
361         sb.appendAll((Collection<?>) null);
362         assertEquals("", sb.toString());
363 
364         sb.clear();
365         sb.appendAll(Collections.EMPTY_LIST);
366         assertEquals("", sb.toString());
367 
368         sb.clear();
369         sb.appendAll(Arrays.asList("foo", "bar", "baz"));
370         assertEquals("foobarbaz", sb.toString());
371     }
372 
373     @Test
374     void testAppendAll_Iterator() {
375         final StrBuilder sb = new StrBuilder();
376         sb.appendAll((Iterator<?>) null);
377         assertEquals("", sb.toString());
378 
379         sb.clear();
380         sb.appendAll(Collections.EMPTY_LIST.iterator());
381         assertEquals("", sb.toString());
382 
383         sb.clear();
384         sb.appendAll(Arrays.asList("foo", "bar", "baz").iterator());
385         assertEquals("foobarbaz", sb.toString());
386     }
387 
388     @Test
389     void testAppendFixedWidthPadLeft() {
390         final StrBuilder sb = new StrBuilder();
391         sb.appendFixedWidthPadLeft("foo", -1, '-');
392         assertEquals("", sb.toString());
393 
394         sb.clear();
395         sb.appendFixedWidthPadLeft("foo", 0, '-');
396         assertEquals("", sb.toString());
397 
398         sb.clear();
399         sb.appendFixedWidthPadLeft("foo", 1, '-');
400         assertEquals("o", sb.toString());
401 
402         sb.clear();
403         sb.appendFixedWidthPadLeft("foo", 2, '-');
404         assertEquals("oo", sb.toString());
405 
406         sb.clear();
407         sb.appendFixedWidthPadLeft("foo", 3, '-');
408         assertEquals("foo", sb.toString());
409 
410         sb.clear();
411         sb.appendFixedWidthPadLeft("foo", 4, '-');
412         assertEquals("-foo", sb.toString());
413 
414         sb.clear();
415         sb.appendFixedWidthPadLeft("foo", 10, '-');
416         assertEquals(10, sb.length());
417         //            1234567890
418         assertEquals("-------foo", sb.toString());
419 
420         sb.clear();
421         sb.setNullText("null");
422         sb.appendFixedWidthPadLeft(null, 5, '-');
423         assertEquals("-null", sb.toString());
424     }
425 
426     @Test
427     void testAppendFixedWidthPadLeft_int() {
428         final StrBuilder sb = new StrBuilder();
429         sb.appendFixedWidthPadLeft(123, -1, '-');
430         assertEquals("", sb.toString());
431 
432         sb.clear();
433         sb.appendFixedWidthPadLeft(123, 0, '-');
434         assertEquals("", sb.toString());
435 
436         sb.clear();
437         sb.appendFixedWidthPadLeft(123, 1, '-');
438         assertEquals("3", sb.toString());
439 
440         sb.clear();
441         sb.appendFixedWidthPadLeft(123, 2, '-');
442         assertEquals("23", sb.toString());
443 
444         sb.clear();
445         sb.appendFixedWidthPadLeft(123, 3, '-');
446         assertEquals("123", sb.toString());
447 
448         sb.clear();
449         sb.appendFixedWidthPadLeft(123, 4, '-');
450         assertEquals("-123", sb.toString());
451 
452         sb.clear();
453         sb.appendFixedWidthPadLeft(123, 10, '-');
454         assertEquals(10, sb.length());
455         //            1234567890
456         assertEquals("-------123", sb.toString());
457     }
458 
459     @Test
460     void testAppendFixedWidthPadRight() {
461         final StrBuilder sb = new StrBuilder();
462         sb.appendFixedWidthPadRight("foo", -1, '-');
463         assertEquals("", sb.toString());
464 
465         sb.clear();
466         sb.appendFixedWidthPadRight("foo", 0, '-');
467         assertEquals("", sb.toString());
468 
469         sb.clear();
470         sb.appendFixedWidthPadRight("foo", 1, '-');
471         assertEquals("f", sb.toString());
472 
473         sb.clear();
474         sb.appendFixedWidthPadRight("foo", 2, '-');
475         assertEquals("fo", sb.toString());
476 
477         sb.clear();
478         sb.appendFixedWidthPadRight("foo", 3, '-');
479         assertEquals("foo", sb.toString());
480 
481         sb.clear();
482         sb.appendFixedWidthPadRight("foo", 4, '-');
483         assertEquals("foo-", sb.toString());
484 
485         sb.clear();
486         sb.appendFixedWidthPadRight("foo", 10, '-');
487         assertEquals(10, sb.length());
488         //            1234567890
489         assertEquals("foo-------", sb.toString());
490 
491         sb.clear();
492         sb.setNullText("null");
493         sb.appendFixedWidthPadRight(null, 5, '-');
494         assertEquals("null-", sb.toString());
495     }
496 
497     @Test
498     void testAppendFixedWidthPadRight_int() {
499         final StrBuilder sb = new StrBuilder();
500         sb.appendFixedWidthPadRight(123, -1, '-');
501         assertEquals("", sb.toString());
502 
503         sb.clear();
504         sb.appendFixedWidthPadRight(123, 0, '-');
505         assertEquals("", sb.toString());
506 
507         sb.clear();
508         sb.appendFixedWidthPadRight(123, 1, '-');
509         assertEquals("1", sb.toString());
510 
511         sb.clear();
512         sb.appendFixedWidthPadRight(123, 2, '-');
513         assertEquals("12", sb.toString());
514 
515         sb.clear();
516         sb.appendFixedWidthPadRight(123, 3, '-');
517         assertEquals("123", sb.toString());
518 
519         sb.clear();
520         sb.appendFixedWidthPadRight(123, 4, '-');
521         assertEquals("123-", sb.toString());
522 
523         sb.clear();
524         sb.appendFixedWidthPadRight(123, 10, '-');
525         assertEquals(10, sb.length());
526         //            1234567890
527         assertEquals("123-------", sb.toString());
528     }
529 
530     @Test
531     void testAppendln_Boolean() {
532         final StrBuilder sb = new StrBuilder();
533         sb.appendln(true);
534         assertEquals("true" + SEP, sb.toString());
535 
536         sb.clear();
537         sb.appendln(false);
538         assertEquals("false" + SEP, sb.toString());
539     }
540 
541     @Test
542     void testAppendln_CharArray() {
543         final int[] count = new int[2];
544         final StrBuilder sb = new StrBuilder() {
545             private static final long serialVersionUID = 1L;
546 
547             @Override
548             public StrBuilder append(final char[] str) {
549                 count[0]++;
550                 return super.append(str);
551             }
552             @Override
553             public StrBuilder appendNewLine() {
554                 count[1]++;
555                 return super.appendNewLine();
556             }
557         };
558         sb.appendln("foo".toCharArray());
559         assertEquals("foo" + SEP, sb.toString());
560         assertEquals(1, count[0]);
561         assertEquals(1, count[1]);
562     }
563 
564     @Test
565     void testAppendln_CharArray_int_int() {
566         final int[] count = new int[2];
567         final StrBuilder sb = new StrBuilder() {
568             private static final long serialVersionUID = 1L;
569 
570             @Override
571             public StrBuilder append(final char[] str, final int startIndex, final int length) {
572                 count[0]++;
573                 return super.append(str, startIndex, length);
574             }
575             @Override
576             public StrBuilder appendNewLine() {
577                 count[1]++;
578                 return super.appendNewLine();
579             }
580         };
581         sb.appendln("foo".toCharArray(), 0, 3);
582         assertEquals("foo" + SEP, sb.toString());
583         assertEquals(1, count[0]);
584         assertEquals(1, count[1]);
585     }
586 
587     @Test
588     void testAppendln_FormattedString() {
589         final int[] count = new int[2];
590         final StrBuilder sb = new StrBuilder() {
591             private static final long serialVersionUID = 1L;
592 
593             @Override
594             public StrBuilder append(final String str) {
595                 count[0]++;
596                 return super.append(str);
597             }
598             @Override
599             public StrBuilder appendNewLine() {
600                 count[1]++;
601                 return super.appendNewLine();
602             }
603         };
604         sb.appendln("Hello %s", "Alice");
605         assertEquals("Hello Alice" + SEP, sb.toString());
606         assertEquals(2, count[0]);  // appendNewLine() calls append(String)
607         assertEquals(1, count[1]);
608     }
609 
610     @Test
611     void testAppendln_Object() {
612         final StrBuilder sb = new StrBuilder();
613         sb.appendln((Object) null);
614         assertEquals("" + SEP, sb.toString());
615 
616         sb.appendln(FOO);
617         assertEquals(SEP + "foo" + SEP, sb.toString());
618 
619         sb.appendln(Integer.valueOf(6));
620         assertEquals(SEP + "foo" + SEP + "6" + SEP, sb.toString());
621     }
622 
623     @Test
624     void testAppendln_PrimitiveNumber() {
625         final StrBuilder sb = new StrBuilder();
626         sb.appendln(0);
627         assertEquals("0" + SEP, sb.toString());
628 
629         sb.clear();
630         sb.appendln(1L);
631         assertEquals("1" + SEP, sb.toString());
632 
633         sb.clear();
634         sb.appendln(2.3f);
635         assertEquals("2.3" + SEP, sb.toString());
636 
637         sb.clear();
638         sb.appendln(4.5d);
639         assertEquals("4.5" + SEP, sb.toString());
640     }
641 
642     @Test
643     void testAppendln_StrBuilder() {
644         final int[] count = new int[2];
645         final StrBuilder sb = new StrBuilder() {
646             private static final long serialVersionUID = 1L;
647 
648             @Override
649             public StrBuilder append(final StrBuilder str) {
650                 count[0]++;
651                 return super.append(str);
652             }
653             @Override
654             public StrBuilder appendNewLine() {
655                 count[1]++;
656                 return super.appendNewLine();
657             }
658         };
659         sb.appendln(new StrBuilder("foo"));
660         assertEquals("foo" + SEP, sb.toString());
661         assertEquals(1, count[0]);
662         assertEquals(1, count[1]);
663     }
664 
665     @Test
666     void testAppendln_StrBuilder_int_int() {
667         final int[] count = new int[2];
668         final StrBuilder sb = new StrBuilder() {
669             private static final long serialVersionUID = 1L;
670 
671             @Override
672             public StrBuilder append(final StrBuilder str, final int startIndex, final int length) {
673                 count[0]++;
674                 return super.append(str, startIndex, length);
675             }
676             @Override
677             public StrBuilder appendNewLine() {
678                 count[1]++;
679                 return super.appendNewLine();
680             }
681         };
682         sb.appendln(new StrBuilder("foo"), 0, 3);
683         assertEquals("foo" + SEP, sb.toString());
684         assertEquals(1, count[0]);
685         assertEquals(1, count[1]);
686     }
687 
688     @Test
689     void testAppendln_String() {
690         final int[] count = new int[2];
691         final StrBuilder sb = new StrBuilder() {
692             private static final long serialVersionUID = 1L;
693 
694             @Override
695             public StrBuilder append(final String str) {
696                 count[0]++;
697                 return super.append(str);
698             }
699             @Override
700             public StrBuilder appendNewLine() {
701                 count[1]++;
702                 return super.appendNewLine();
703             }
704         };
705         sb.appendln("foo");
706         assertEquals("foo" + SEP, sb.toString());
707         assertEquals(2, count[0]);  // appendNewLine() calls append(String)
708         assertEquals(1, count[1]);
709     }
710 
711     @Test
712     void testAppendln_String_int_int() {
713         final int[] count = new int[2];
714         final StrBuilder sb = new StrBuilder() {
715             private static final long serialVersionUID = 1L;
716 
717             @Override
718             public StrBuilder append(final String str, final int startIndex, final int length) {
719                 count[0]++;
720                 return super.append(str, startIndex, length);
721             }
722             @Override
723             public StrBuilder appendNewLine() {
724                 count[1]++;
725                 return super.appendNewLine();
726             }
727         };
728         sb.appendln("foo", 0, 3);
729         assertEquals("foo" + SEP, sb.toString());
730         assertEquals(1, count[0]);
731         assertEquals(1, count[1]);
732     }
733 
734     @Test
735     void testAppendln_StringBuffer() {
736         final int[] count = new int[2];
737         final StrBuilder sb = new StrBuilder() {
738             private static final long serialVersionUID = 1L;
739 
740             @Override
741             public StrBuilder append(final StringBuffer str) {
742                 count[0]++;
743                 return super.append(str);
744             }
745             @Override
746             public StrBuilder appendNewLine() {
747                 count[1]++;
748                 return super.appendNewLine();
749             }
750         };
751         sb.appendln(new StringBuffer("foo"));
752         assertEquals("foo" + SEP, sb.toString());
753         assertEquals(1, count[0]);
754         assertEquals(1, count[1]);
755     }
756 
757     @Test
758     void testAppendln_StringBuffer_int_int() {
759         final int[] count = new int[2];
760         final StrBuilder sb = new StrBuilder() {
761             private static final long serialVersionUID = 1L;
762 
763             @Override
764             public StrBuilder append(final StringBuffer str, final int startIndex, final int length) {
765                 count[0]++;
766                 return super.append(str, startIndex, length);
767             }
768             @Override
769             public StrBuilder appendNewLine() {
770                 count[1]++;
771                 return super.appendNewLine();
772             }
773         };
774         sb.appendln(new StringBuffer("foo"), 0, 3);
775         assertEquals("foo" + SEP, sb.toString());
776         assertEquals(1, count[0]);
777         assertEquals(1, count[1]);
778     }
779 
780     @Test
781     void testAppendln_StringBuilder() {
782         final int[] count = new int[2];
783         final StrBuilder sb = new StrBuilder() {
784             private static final long serialVersionUID = 1L;
785 
786             @Override
787             public StrBuilder append(final StringBuilder str) {
788                 count[0]++;
789                 return super.append(str);
790             }
791             @Override
792             public StrBuilder appendNewLine() {
793                 count[1]++;
794                 return super.appendNewLine();
795             }
796         };
797         sb.appendln(new StringBuilder("foo"));
798         assertEquals("foo" + SEP, sb.toString());
799         assertEquals(1, count[0]);
800         assertEquals(1, count[1]);
801     }
802 
803     @Test
804     void testAppendln_StringBuilder_int_int() {
805         final int[] count = new int[2];
806         final StrBuilder sb = new StrBuilder() {
807             private static final long serialVersionUID = 1L;
808 
809             @Override
810             public StrBuilder append(final StringBuilder str, final int startIndex, final int length) {
811                 count[0]++;
812                 return super.append(str, startIndex, length);
813             }
814             @Override
815             public StrBuilder appendNewLine() {
816                 count[1]++;
817                 return super.appendNewLine();
818             }
819         };
820         sb.appendln(new StringBuilder("foo"), 0, 3);
821         assertEquals("foo" + SEP, sb.toString());
822         assertEquals(1, count[0]);
823         assertEquals(1, count[1]);
824     }
825 
826     @Test
827     void testAppendNewLine() {
828         StrBuilder sb = new StrBuilder("---");
829         sb.appendNewLine().append("+++");
830         assertEquals("---" + SEP + "+++", sb.toString());
831 
832         sb = new StrBuilder("---");
833         sb.setNewLineText("#").appendNewLine().setNewLineText(null).appendNewLine();
834         assertEquals("---#" + SEP, sb.toString());
835     }
836 
837     @Test
838     void testAppendPadding() {
839         final StrBuilder sb = new StrBuilder();
840         sb.append("foo");
841         assertEquals("foo", sb.toString());
842 
843         sb.appendPadding(-1, '-');
844         assertEquals("foo", sb.toString());
845 
846         sb.appendPadding(0, '-');
847         assertEquals("foo", sb.toString());
848 
849         sb.appendPadding(1, '-');
850         assertEquals("foo-", sb.toString());
851 
852         sb.appendPadding(16, '-');
853         assertEquals(20, sb.length());
854         //            12345678901234567890
855         assertEquals("foo-----------------", sb.toString());
856     }
857 
858     @Test
859     void testAppendSeparator_char() {
860         final StrBuilder sb = new StrBuilder();
861         sb.appendSeparator(',');  // no effect
862         assertEquals("", sb.toString());
863         sb.append("foo");
864         assertEquals("foo", sb.toString());
865         sb.appendSeparator(',');
866         assertEquals("foo,", sb.toString());
867     }
868 
869     @Test
870     void testAppendSeparator_char_char() {
871         final StrBuilder sb = new StrBuilder();
872         final char startSeparator = ':';
873         final char standardSeparator = ',';
874         final String foo = "foo";
875         sb.appendSeparator(standardSeparator, startSeparator);  // no effect
876         assertEquals(String.valueOf(startSeparator), sb.toString());
877         sb.append(foo);
878         assertEquals(startSeparator + foo, sb.toString());
879         sb.appendSeparator(standardSeparator, startSeparator);
880         assertEquals(startSeparator + foo + standardSeparator, sb.toString());
881     }
882 
883     @Test
884     void testAppendSeparator_char_int() {
885         final StrBuilder sb = new StrBuilder();
886         sb.appendSeparator(',', 0);  // no effect
887         assertEquals("", sb.toString());
888         sb.append("foo");
889         assertEquals("foo", sb.toString());
890         sb.appendSeparator(',', 1);
891         assertEquals("foo,", sb.toString());
892 
893         sb.appendSeparator(',', -1);  // no effect
894         assertEquals("foo,", sb.toString());
895     }
896 
897     @Test
898     void testAppendSeparator_String() {
899         final StrBuilder sb = new StrBuilder();
900         sb.appendSeparator(",");  // no effect
901         assertEquals("", sb.toString());
902         sb.append("foo");
903         assertEquals("foo", sb.toString());
904         sb.appendSeparator(",");
905         assertEquals("foo,", sb.toString());
906     }
907 
908     @Test
909     void testAppendSeparator_String_int() {
910         final StrBuilder sb = new StrBuilder();
911         sb.appendSeparator(",", 0);  // no effect
912         assertEquals("", sb.toString());
913         sb.append("foo");
914         assertEquals("foo", sb.toString());
915         sb.appendSeparator(",", 1);
916         assertEquals("foo,", sb.toString());
917 
918         sb.appendSeparator(",", -1);  // no effect
919         assertEquals("foo,", sb.toString());
920     }
921 
922     @Test
923     void testAppendSeparator_String_String() {
924         final StrBuilder sb = new StrBuilder();
925         final String startSeparator = "order by ";
926         final String standardSeparator = ",";
927         final String foo = "foo";
928         sb.appendSeparator(null, null);
929         assertEquals("", sb.toString());
930         sb.appendSeparator(standardSeparator, null);
931         assertEquals("", sb.toString());
932         sb.appendSeparator(standardSeparator, startSeparator);
933         assertEquals(startSeparator, sb.toString());
934         sb.appendSeparator(null, null);
935         assertEquals(startSeparator, sb.toString());
936         sb.appendSeparator(null, startSeparator);
937         assertEquals(startSeparator, sb.toString());
938         sb.append(foo);
939         assertEquals(startSeparator + foo, sb.toString());
940         sb.appendSeparator(standardSeparator, startSeparator);
941         assertEquals(startSeparator + foo + standardSeparator, sb.toString());
942     }
943 
944     @Test
945     void testAppendWithNullText() {
946         final StrBuilder sb = new StrBuilder();
947         sb.setNullText("NULL");
948         assertEquals("", sb.toString());
949 
950         sb.appendNull();
951         assertEquals("NULL", sb.toString());
952 
953         sb.append((Object) null);
954         assertEquals("NULLNULL", sb.toString());
955 
956         sb.append(FOO);
957         assertEquals("NULLNULLfoo", sb.toString());
958 
959         sb.append((String) null);
960         assertEquals("NULLNULLfooNULL", sb.toString());
961 
962         sb.append("");
963         assertEquals("NULLNULLfooNULL", sb.toString());
964 
965         sb.append("bar");
966         assertEquals("NULLNULLfooNULLbar", sb.toString());
967 
968         sb.append((StringBuffer) null);
969         assertEquals("NULLNULLfooNULLbarNULL", sb.toString());
970 
971         sb.append(new StringBuffer("baz"));
972         assertEquals("NULLNULLfooNULLbarNULLbaz", sb.toString());
973     }
974 
975     @Test
976     void testAppendWithSeparators_Array() {
977         final StrBuilder sb = new StrBuilder();
978         sb.appendWithSeparators((Object[]) null, ",");
979         assertEquals("", sb.toString());
980 
981         sb.clear();
982         sb.appendWithSeparators(new Object[0], ",");
983         assertEquals("", sb.toString());
984 
985         sb.clear();
986         sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, ",");
987         assertEquals("foo,bar,baz", sb.toString());
988 
989         sb.clear();
990         sb.appendWithSeparators(new Object[]{"foo", "bar", "baz"}, null);
991         assertEquals("foobarbaz", sb.toString());
992 
993         sb.clear();
994         sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
995         assertEquals("foo,,baz", sb.toString());
996     }
997 
998     @Test
999     void testAppendWithSeparators_Collection() {
1000         final StrBuilder sb = new StrBuilder();
1001         sb.appendWithSeparators((Collection<?>) null, ",");
1002         assertEquals("", sb.toString());
1003 
1004         sb.clear();
1005         sb.appendWithSeparators(Collections.EMPTY_LIST, ",");
1006         assertEquals("", sb.toString());
1007 
1008         sb.clear();
1009         sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), ",");
1010         assertEquals("foo,bar,baz", sb.toString());
1011 
1012         sb.clear();
1013         sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz"), null);
1014         assertEquals("foobarbaz", sb.toString());
1015 
1016         sb.clear();
1017         sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
1018         assertEquals("foo,,baz", sb.toString());
1019     }
1020     @Test
1021     void testAppendWithSeparators_Iterator() {
1022         final StrBuilder sb = new StrBuilder();
1023         sb.appendWithSeparators((Iterator<?>) null, ",");
1024         assertEquals("", sb.toString());
1025 
1026         sb.clear();
1027         sb.appendWithSeparators(Collections.EMPTY_LIST.iterator(), ",");
1028         assertEquals("", sb.toString());
1029 
1030         sb.clear();
1031         sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), ",");
1032         assertEquals("foo,bar,baz", sb.toString());
1033 
1034         sb.clear();
1035         sb.appendWithSeparators(Arrays.asList("foo", "bar", "baz").iterator(), null);
1036         assertEquals("foobarbaz", sb.toString());
1037 
1038         sb.clear();
1039         sb.appendWithSeparators(Arrays.asList("foo", null, "baz").iterator(), ",");
1040         assertEquals("foo,,baz", sb.toString());
1041     }
1042 
1043     @Test
1044     void testAppendWithSeparatorsWithNullText() {
1045         final StrBuilder sb = new StrBuilder();
1046         sb.setNullText("null");
1047         sb.appendWithSeparators(new Object[]{"foo", null, "baz"}, ",");
1048         assertEquals("foo,null,baz", sb.toString());
1049 
1050         sb.clear();
1051         sb.appendWithSeparators(Arrays.asList("foo", null, "baz"), ",");
1052         assertEquals("foo,null,baz", sb.toString());
1053     }
1054 
1055     @Test
1056     void testInsert() {
1057         final StrBuilder sb = new StrBuilder();
1058         sb.append("barbaz");
1059         assertEquals("barbaz", sb.toString());
1060         assertIndexOutOfBoundsException(() -> sb.insert(-1, FOO), "insert(-1, Object) expected StringIndexOutOfBoundsException");
1061         assertIndexOutOfBoundsException(() -> sb.insert(7, FOO), "insert(7, Object) expected StringIndexOutOfBoundsException");
1062         sb.insert(0, (Object) null);
1063         assertEquals("barbaz", sb.toString());
1064         sb.insert(0, FOO);
1065         assertEquals("foobarbaz", sb.toString());
1066         sb.clear();
1067         sb.append("barbaz");
1068         assertEquals("barbaz", sb.toString());
1069         assertIndexOutOfBoundsException(() -> sb.insert(-1, "foo"), "insert(-1, String) expected StringIndexOutOfBoundsException");
1070         assertIndexOutOfBoundsException(() -> sb.insert(7, "foo"), "insert(7, String) expected StringIndexOutOfBoundsException");
1071         sb.insert(0, (String) null);
1072         assertEquals("barbaz", sb.toString());
1073         sb.insert(0, "foo");
1074         assertEquals("foobarbaz", sb.toString());
1075         sb.clear();
1076         sb.append("barbaz");
1077         assertEquals("barbaz", sb.toString());
1078         assertIndexOutOfBoundsException(() -> sb.insert(-1, new char[] { 'f', 'o', 'o' }),
1079                 "insert(-1, char[]) expected StringIndexOutOfBoundsException");
1080         assertIndexOutOfBoundsException(() -> sb.insert(7, new char[] { 'f', 'o', 'o' }),
1081                 "insert(7, char[]) expected StringIndexOutOfBoundsException");
1082         sb.insert(0, (char[]) null);
1083         assertEquals("barbaz", sb.toString());
1084         sb.insert(0, new char[0]);
1085         assertEquals("barbaz", sb.toString());
1086         sb.insert(0, new char[] { 'f', 'o', 'o' });
1087         assertEquals("foobarbaz", sb.toString());
1088         sb.clear();
1089         sb.append("barbaz");
1090         assertEquals("barbaz", sb.toString());
1091         assertIndexOutOfBoundsException(() -> sb.insert(-1, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3),
1092                 "insert(-1, char[], 3, 3) expected StringIndexOutOfBoundsException");
1093         assertIndexOutOfBoundsException(() -> sb.insert(7, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3),
1094                 "insert(7, char[], 3, 3) expected StringIndexOutOfBoundsException");
1095         sb.insert(0, null, 0, 0);
1096         assertEquals("barbaz", sb.toString());
1097         sb.insert(0, new char[0], 0, 0);
1098         assertEquals("barbaz", sb.toString());
1099         assertIndexOutOfBoundsException(() -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, -1, 3),
1100                 "insert(0, char[], -1, 3) expected StringIndexOutOfBoundsException");
1101         assertIndexOutOfBoundsException(() -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 10, 3),
1102                 "insert(0, char[], 10, 3) expected StringIndexOutOfBoundsException");
1103         assertIndexOutOfBoundsException(() -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, -1),
1104                 "insert(0, char[], 0, -1) expected StringIndexOutOfBoundsException");
1105         assertIndexOutOfBoundsException(() -> sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, 10),
1106                 "insert(0, char[], 0, 10) expected StringIndexOutOfBoundsException");
1107         sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 0, 0);
1108         assertEquals("barbaz", sb.toString());
1109         sb.insert(0, new char[] { 'a', 'b', 'c', 'f', 'o', 'o', 'd', 'e', 'f' }, 3, 3);
1110         assertEquals("foobarbaz", sb.toString());
1111         sb.clear();
1112         sb.append("barbaz");
1113         assertEquals("barbaz", sb.toString());
1114         assertIndexOutOfBoundsException(() -> sb.insert(-1, true), "insert(-1, boolean) expected StringIndexOutOfBoundsException");
1115         assertIndexOutOfBoundsException(() -> sb.insert(7, true), "insert(7, boolean) expected StringIndexOutOfBoundsException");
1116         sb.insert(0, true);
1117         assertEquals("truebarbaz", sb.toString());
1118         sb.insert(0, false);
1119         assertEquals("falsetruebarbaz", sb.toString());
1120         sb.clear();
1121         sb.append("barbaz");
1122         assertEquals("barbaz", sb.toString());
1123         assertIndexOutOfBoundsException(() -> sb.insert(-1, '!'), "insert(-1, char) expected StringIndexOutOfBoundsException");
1124         assertIndexOutOfBoundsException(() -> sb.insert(7, '!'), "insert(7, char) expected StringIndexOutOfBoundsException");
1125         sb.insert(0, '!');
1126         assertEquals("!barbaz", sb.toString());
1127         sb.clear();
1128         sb.append("barbaz");
1129         assertEquals("barbaz", sb.toString());
1130         assertIndexOutOfBoundsException(() -> sb.insert(-1, 0), "insert(-1, int) expected StringIndexOutOfBoundsException");
1131         assertIndexOutOfBoundsException(() -> sb.insert(7, 0), "insert(7, int) expected StringIndexOutOfBoundsException");
1132         sb.insert(0, '0');
1133         assertEquals("0barbaz", sb.toString());
1134         sb.clear();
1135         sb.append("barbaz");
1136         assertEquals("barbaz", sb.toString());
1137         assertIndexOutOfBoundsException(() -> sb.insert(-1, 1L), "insert(-1, long) expected StringIndexOutOfBoundsException");
1138         assertIndexOutOfBoundsException(() -> sb.insert(7, 1L), "insert(7, long) expected StringIndexOutOfBoundsException");
1139         sb.insert(0, 1L);
1140         assertEquals("1barbaz", sb.toString());
1141         sb.clear();
1142         sb.append("barbaz");
1143         assertEquals("barbaz", sb.toString());
1144         assertIndexOutOfBoundsException(() -> sb.insert(-1, 2.3F), "insert(-1, float) expected StringIndexOutOfBoundsException");
1145         assertIndexOutOfBoundsException(() -> sb.insert(7, 2.3F), "insert(7, float) expected StringIndexOutOfBoundsException");
1146         sb.insert(0, 2.3F);
1147         assertEquals("2.3barbaz", sb.toString());
1148         sb.clear();
1149         sb.append("barbaz");
1150         assertEquals("barbaz", sb.toString());
1151         assertIndexOutOfBoundsException(() -> sb.insert(-1, 4.5D), "insert(-1, double) expected StringIndexOutOfBoundsException");
1152         assertIndexOutOfBoundsException(() -> sb.insert(7, 4.5D), "insert(7, double) expected StringIndexOutOfBoundsException");
1153         sb.insert(0, 4.5D);
1154         assertEquals("4.5barbaz", sb.toString());
1155     }
1156 
1157     @Test
1158     void testInsertWithNullText() {
1159         final StrBuilder sb = new StrBuilder();
1160         sb.setNullText("null");
1161         sb.append("barbaz");
1162         assertEquals("barbaz", sb.toString());
1163         assertIndexOutOfBoundsException(() -> sb.insert(-1, FOO), "insert(-1, Object) expected StringIndexOutOfBoundsException");
1164         assertIndexOutOfBoundsException(() -> sb.insert(7, FOO), "insert(7, Object) expected StringIndexOutOfBoundsException");
1165         sb.insert(0, (Object) null);
1166         assertEquals("nullbarbaz", sb.toString());
1167         sb.insert(0, FOO);
1168         assertEquals("foonullbarbaz", sb.toString());
1169         sb.clear();
1170         sb.append("barbaz");
1171         assertEquals("barbaz", sb.toString());
1172         assertIndexOutOfBoundsException(() -> sb.insert(-1, "foo"), "insert(-1, String) expected StringIndexOutOfBoundsException");
1173         assertIndexOutOfBoundsException(() -> sb.insert(7, "foo"), "insert(7, String) expected StringIndexOutOfBoundsException");
1174         sb.insert(0, (String) null);
1175         assertEquals("nullbarbaz", sb.toString());
1176         sb.insert(0, "foo");
1177         assertEquals("foonullbarbaz", sb.toString());
1178         sb.insert(0, (char[]) null);
1179         assertEquals("nullfoonullbarbaz", sb.toString());
1180         sb.insert(0, null, 0, 0);
1181         assertEquals("nullnullfoonullbarbaz", sb.toString());
1182     }
1183 
1184     // See: https://issues.apache.org/jira/browse/LANG-299
1185     @Test
1186     void testLang299() {
1187         final StrBuilder sb = new StrBuilder(1);
1188         sb.appendFixedWidthPadRight("foo", 1, '-');
1189         assertEquals("f", sb.toString());
1190     }
1191 }