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