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    *      http://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.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   * Tests {@link StrBuilder}.
35   *
36   * @deprecated This class will be removed in 2.0.
37   */
38  @Deprecated
39  public class StrBuilderAppendInsertTest {
40  
41      /** The system line separator. */
42      private static final String SEP = System.lineSeparator();
43  
44      /** Test subclass of Object, with a toString method. */
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              // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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         // group separator depends on system locale
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")); // Check it supports StringBuilder
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
314         }
315 
316         try {
317             sb.append("bar", 3, 1);
318             fail("append(char[], 3,) expected IndexOutOfBoundsException");
319         } catch (final IndexOutOfBoundsException e) {
320             // expected
321         }
322 
323         try {
324             sb.append("bar", 1, -1);
325             fail("append(char[],, -1) expected IndexOutOfBoundsException");
326         } catch (final IndexOutOfBoundsException e) {
327             // expected
328         }
329 
330         try {
331             sb.append("bar", 1, 3);
332             fail("append(char[], 1, 3) expected IndexOutOfBoundsException");
333         } catch (final IndexOutOfBoundsException e) {
334             // expected
335         }
336 
337         try {
338             sb.append("bar", -1, 3);
339             fail("append(char[], -1, 3) expected IndexOutOfBoundsException");
340         } catch (final IndexOutOfBoundsException e) {
341             // expected
342         }
343 
344         try {
345             sb.append("bar", 4, 0);
346             fail("append(char[], 4, 0) expected IndexOutOfBoundsException");
347         } catch (final IndexOutOfBoundsException e) {
348             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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             // expected
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         // 1234567890
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         // 1234567890
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         // 1234567890
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         // 1234567890
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]); // appendNewLine() calls append(String)
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]); // appendNewLine() calls append(String)
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         // 12345678901234567890
1043         assertEquals("foo-----------------", sb.toString());
1044     }
1045 
1046     @Test
1047     public void testAppendSeparator_char() {
1048         final StrBuilder sb = new StrBuilder();
1049         sb.appendSeparator(','); // no effect
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); // no effect
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); // no effect
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); // no effect
1082         assertEquals("foo,", sb.toString());
1083     }
1084 
1085     @Test
1086     public void testAppendSeparator_String() {
1087         final StrBuilder sb = new StrBuilder();
1088         sb.appendSeparator(","); // no effect
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); // no effect
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); // no effect
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     /** See: https://issues.apache.org/jira/browse/LANG-299 */
1429     @Test
1430     public void testLang299() {
1431         final StrBuilder sb = new StrBuilder(1);
1432         sb.appendFixedWidthPadRight("foo", 1, '-');
1433         assertEquals("f", sb.toString());
1434     }
1435 }