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