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 18package org.apache.harmony.tests.java.lang; 19 20import java.io.UnsupportedEncodingException; 21import java.util.Locale; 22 23public class String2Test extends junit.framework.TestCase { 24 25 String hw1 = "HelloWorld"; 26 27 String hw2 = "HelloWorld"; 28 29 String hwlc = "helloworld"; 30 31 String hwuc = "HELLOWORLD"; 32 33 String hello1 = "Hello"; 34 35 String world1 = "World"; 36 37 String comp11 = "Test String"; 38 39 Object obj = new Object(); 40 41 char[] buf = { 'W', 'o', 'r', 'l', 'd' }; 42 43 char[] rbuf = new char[5]; 44 45 /** 46 * java.lang.String#String() 47 */ 48 public void test_Constructor() { 49 // Test for method java.lang.String() 50 assertTrue("Created incorrect string", new String().equals("")); 51 } 52 53 /** 54 * java.lang.String#String(byte[]) 55 */ 56 public void test_Constructor$B() { 57 // Test for method java.lang.String(byte []) 58 assertTrue("Failed to create string", new String(hw1.getBytes()) 59 .equals(hw1)); 60 } 61 62 /** 63 * java.lang.String#String(byte[], int) 64 */ 65 @SuppressWarnings("deprecation") 66 public void test_Constructor$BI() { 67 // Test for method java.lang.String(byte [], int) 68 String s = new String(new byte[] { 65, 66, 67, 68, 69 }, 0); 69 assertTrue("Incorrect string returned: " + s, s.equals("ABCDE")); 70 s = new String(new byte[] { 65, 66, 67, 68, 69 }, 1); 71 assertTrue("Did not use nonzero hibyte", !s.equals("ABCDE")); 72 } 73 74 /** 75 * java.lang.String#String(byte[], int, int) 76 */ 77 public void test_Constructor$BII() { 78 // Test for method java.lang.String(byte [], int, int) 79 assertTrue("Failed to create string", new String(hw1.getBytes(), 0, hw1 80 .getBytes().length).equals(hw1)); 81 82 boolean exception = false; 83 try { 84 new String(new byte[0], 0, Integer.MAX_VALUE); 85 } catch (IndexOutOfBoundsException e) { 86 exception = true; 87 } 88 assertTrue("Did not throw exception", exception); 89 } 90 91 /** 92 * java.lang.String#String(byte[], int, int, int) 93 */ 94 @SuppressWarnings("deprecation") 95 public void test_Constructor$BIII() { 96 // Test for method java.lang.String(byte [], int, int, int) 97 String s = new String(new byte[] { 65, 66, 67, 68, 69 }, 0, 1, 3); 98 assertTrue("Incorrect string returned: " + s, s.equals("BCD")); 99 s = new String(new byte[] { 65, 66, 67, 68, 69 }, 1, 0, 5); 100 assertTrue("Did not use nonzero hibyte", !s.equals("ABCDE")); 101 } 102 103 /** 104 * java.lang.String#String(byte[], int, int, java.lang.String) 105 */ 106 public void test_Constructor$BIILjava_lang_String() throws Exception { 107 // Test for method java.lang.String(byte [], int, int, java.lang.String) 108 String s = null; 109 s = new String(new byte[] { 65, 66, 67, 68, 69 }, 0, 5, "8859_1"); 110 assertTrue("Incorrect string returned: " + s, s.equals("ABCDE")); 111 // Regression for HARMONY-1111 112 assertNotNull(new String(new byte[] { (byte) 0xC0 }, 0, 1, "UTF-8")); 113 } 114 115 /** 116 * java.lang.String#String(byte[], java.lang.String) 117 */ 118 public void test_Constructor$BLjava_lang_String() throws Exception { 119 // Test for method java.lang.String(byte [], java.lang.String) 120 String s = null; 121 s = new String(new byte[] { 65, 66, 67, 68, 69 }, "8859_1"); 122 assertTrue("Incorrect string returned: " + s, s.equals("ABCDE")); 123 } 124 125 /** 126 * java.lang.String#String(char[]) 127 */ 128 public void test_Constructor$C() { 129 // Test for method java.lang.String(char []) 130 assertEquals("Failed Constructor test", "World", new String(buf)); 131 } 132 133 /** 134 * java.lang.String#String(char[], int, int) 135 */ 136 public void test_Constructor$CII() { 137 // Test for method java.lang.String(char [], int, int) 138 char[] buf = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' }; 139 String s = new String(buf, 0, buf.length); 140 assertTrue("Incorrect string created", hw1.equals(s)); 141 142 boolean exception = false; 143 try { 144 new String(new char[0], 0, Integer.MAX_VALUE); 145 } catch (IndexOutOfBoundsException e) { 146 exception = true; 147 } 148 assertTrue("Did not throw exception", exception); 149 } 150 151 /** 152 * java.lang.String#String(int[], int, int) 153 */ 154 public void test_Constructor$III() { 155 // Test for method java.lang.String(int [], int, int) 156 try { 157 new String(new int[0], 2, Integer.MAX_VALUE); 158 fail("Did not throw exception"); 159 } catch (IndexOutOfBoundsException e) { 160 // expected 161 } 162 } 163 164 /** 165 * java.lang.String#String(java.lang.String) 166 */ 167 public void test_ConstructorLjava_lang_String() { 168 // Test for method java.lang.String(java.lang.String) 169 String s = new String("Hello World"); 170 assertEquals("Failed to construct correct string", "Hello World", s); 171 } 172 173 /** 174 * java.lang.String#String(java.lang.StringBuffer) 175 */ 176 public void test_ConstructorLjava_lang_StringBuffer() { 177 // Test for method java.lang.String(java.lang.StringBuffer) 178 StringBuffer sb = new StringBuffer(); 179 sb.append("HelloWorld"); 180 assertEquals("Created incorrect string", "HelloWorld", new String(sb)); 181 } 182 183 /** 184 * java.lang.String#charAt(int) 185 */ 186 public void test_charAtI() { 187 // Test for method char java.lang.String.charAt(int) 188 assertTrue("Incorrect character returned", hw1.charAt(5) == 'W' 189 && (hw1.charAt(1) != 'Z')); 190 } 191 192 /** 193 * java.lang.String#compareTo(java.lang.String) 194 */ 195 public void test_compareToLjava_lang_String() { 196 // Test for method int java.lang.String.compareTo(java.lang.String) 197 assertTrue("Returned incorrect value for first < second", "aaaaab" 198 .compareTo("aaaaac") < 0); 199 assertEquals("Returned incorrect value for first = second", 0, "aaaaac" 200 .compareTo("aaaaac")); 201 assertTrue("Returned incorrect value for first > second", "aaaaac" 202 .compareTo("aaaaab") > 0); 203 assertTrue("Considered case to not be of importance", !("A" 204 .compareTo("a") == 0)); 205 206 try { 207 "fixture".compareTo(null); 208 fail("No NPE"); 209 } catch (NullPointerException e) { 210 } 211 } 212 213 /** 214 * java.lang.String#compareToIgnoreCase(java.lang.String) 215 */ 216 public void test_compareToIgnoreCaseLjava_lang_String() { 217 // Test for method int 218 // java.lang.String.compareToIgnoreCase(java.lang.String) 219 assertTrue("Returned incorrect value for first < second", "aaaaab" 220 .compareToIgnoreCase("aaaaac") < 0); 221 assertEquals("Returned incorrect value for first = second", 0, "aaaaac" 222 .compareToIgnoreCase("aaaaac")); 223 assertTrue("Returned incorrect value for first > second", "aaaaac" 224 .compareToIgnoreCase("aaaaab") > 0); 225 assertEquals("Considered case to not be of importance", 0, "A" 226 .compareToIgnoreCase("a")); 227 228 assertTrue("0xbf should not compare = to 'ss'", "\u00df" 229 .compareToIgnoreCase("ss") != 0); 230 assertEquals("0x130 should compare = to 'i'", 0, "\u0130" 231 .compareToIgnoreCase("i")); 232 assertEquals("0x131 should compare = to 'i'", 0, "\u0131" 233 .compareToIgnoreCase("i")); 234 235 Locale defLocale = Locale.getDefault(); 236 try { 237 Locale.setDefault(new Locale("tr", "")); 238 assertEquals("Locale tr: 0x130 should compare = to 'i'", 0, 239 "\u0130".compareToIgnoreCase("i")); 240 assertEquals("Locale tr: 0x131 should compare = to 'i'", 0, 241 "\u0131".compareToIgnoreCase("i")); 242 } finally { 243 Locale.setDefault(defLocale); 244 } 245 246 try { 247 "fixture".compareToIgnoreCase(null); 248 fail("No NPE"); 249 } catch (NullPointerException e) { 250 } 251 } 252 253 /** 254 * java.lang.String#concat(java.lang.String) 255 */ 256 public void test_concatLjava_lang_String() { 257 // Test for method java.lang.String 258 // java.lang.String.concat(java.lang.String) 259 assertTrue("Concatenation failed to produce correct string", hello1 260 .concat(world1).equals(hw1)); 261 boolean exception = false; 262 try { 263 String a = new String("test"); 264 String b = null; 265 a.concat(b); 266 } catch (NullPointerException e) { 267 exception = true; 268 } 269 assertTrue("Concatenation failed to throw NP exception (1)", exception); 270 exception = false; 271 try { 272 String a = new String(""); 273 String b = null; 274 a.concat(b); 275 } catch (NullPointerException e) { 276 exception = true; 277 } 278 assertTrue("Concatenation failed to throw NP exception (2)", exception); 279 280 String s1 = ""; 281 String s2 = "s2"; 282 String s3 = s1.concat(s2); 283 assertEquals(s2, s3); 284 // The RI returns a new string even when it's the same as the argument string. 285 // assertNotSame(s2, s3); 286 s3 = s2.concat(s1); 287 assertEquals(s2, s3); 288 // Neither Android nor the RI returns a new string when it's the same as *this*. 289 // assertNotSame(s2, s3); 290 291 s3 = s2.concat(s1); 292 assertSame(s2, s3); 293 } 294 295 /** 296 * java.lang.String#copyValueOf(char[]) 297 */ 298 public void test_copyValueOf$C() { 299 // Test for method java.lang.String java.lang.String.copyValueOf(char 300 // []) 301 char[] t = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' }; 302 assertEquals("copyValueOf returned incorrect String", "HelloWorld", 303 String.copyValueOf(t)); 304 } 305 306 /** 307 * java.lang.String#copyValueOf(char[], int, int) 308 */ 309 public void test_copyValueOf$CII() { 310 // Test for method java.lang.String java.lang.String.copyValueOf(char 311 // [], int, int) 312 char[] t = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' }; 313 assertEquals("copyValueOf returned incorrect String", "World", String 314 .copyValueOf(t, 5, 5)); 315 } 316 317 /** 318 * java.lang.String#endsWith(java.lang.String) 319 */ 320 public void test_endsWithLjava_lang_String() { 321 // Test for method boolean java.lang.String.endsWith(java.lang.String) 322 assertTrue("Failed to fine ending string", hw1.endsWith("ld")); 323 } 324 325 /** 326 * java.lang.String#equals(java.lang.Object) 327 */ 328 public void test_equalsLjava_lang_Object() { 329 assertEquals("String not equal", hw1, hw2); 330 assertEquals("Empty string equals check", "", ""); 331 assertEquals("Null string equals check", (String) null, (String) null); 332 333 assertFalse("Unequal strings reports as equal", hw1.equals(comp11)); 334 assertFalse("Null string comparison failed", hw1.equals((String) null)); 335 } 336 337 /** 338 * java.lang.String#equalsIgnoreCase(java.lang.String) 339 */ 340 public void test_equalsIgnoreCaseLjava_lang_String() { 341 // Test for method boolean 342 // java.lang.String.equalsIgnoreCase(java.lang.String) 343 assertTrue("lc version returned unequal to uc", hwlc 344 .equalsIgnoreCase(hwuc)); 345 } 346 347 /** 348 * java.lang.String#getBytes() 349 */ 350 public void test_getBytes() { 351 // Test for method byte [] java.lang.String.getBytes() 352 byte[] sbytes = hw1.getBytes(); 353 354 for (int i = 0; i < hw1.length(); i++) { 355 assertTrue("Returned incorrect bytes", sbytes[i] == (byte) hw1.charAt(i)); 356 } 357 358 char[] chars = new char[1]; 359 for (int i = 0; i < 65536; i++) { 360 // skip surrogates 361 if (i == 0xd800) 362 i = 0xe000; 363 byte[] result = null; 364 chars[0] = (char) i; 365 String string = new String(chars); 366 try { 367 result = string.getBytes("8859_1"); 368 if (i < 256) { 369 assertEquals((byte) i, result[0]); 370 } else { 371 /* 372 * Substitute character should be 0x1A [1], but may be '?' 373 * character. [1] 374 * http://en.wikipedia.org/wiki/Substitute_character 375 */ 376 assertTrue(result[0] == '?' || result[0] == 0x1a); 377 } 378 } catch (java.io.UnsupportedEncodingException e) { 379 } 380 try { 381 result = string.getBytes("UTF8"); 382 int length = i < 0x80 ? 1 : (i < 0x800 ? 2 : 3); 383 assertTrue("Wrong length UTF8: " + Integer.toHexString(i), 384 result.length == length); 385 assertTrue( 386 "Wrong bytes UTF8: " + Integer.toHexString(i), 387 (i < 0x80 && result[0] == i) 388 || (i >= 0x80 389 && i < 0x800 390 && result[0] == (byte) (0xc0 | ((i & 0x7c0) >> 6)) && result[1] == (byte) (0x80 | (i & 0x3f))) 391 || (i >= 0x800 392 && result[0] == (byte) (0xe0 | (i >> 12)) 393 && result[1] == (byte) (0x80 | ((i & 0xfc0) >> 6)) && result[2] == (byte) (0x80 | (i & 0x3f)))); 394 } catch (java.io.UnsupportedEncodingException e) { 395 } 396 397 String bytes = null; 398 try { 399 bytes = new String(result, "UTF8"); 400 assertTrue("Wrong UTF8 byte length: " + bytes.length() + "(" 401 + i + ")", bytes.length() == 1); 402 assertTrue( 403 "Wrong char UTF8: " 404 + Integer.toHexString(bytes.charAt(0)) + " (" 405 + i + ")", bytes.charAt(0) == i); 406 } catch (java.io.UnsupportedEncodingException e) { 407 } 408 } 409 410 byte[] bytes = new byte[1]; 411 for (int i = 0; i < 256; i++) { 412 bytes[0] = (byte) i; 413 String result = null; 414 try { 415 result = new String(bytes, "8859_1"); 416 assertEquals("Wrong char length", 1, result.length()); 417 assertTrue("Wrong char value", result.charAt(0) == (char) i); 418 } catch (java.io.UnsupportedEncodingException e) { 419 } 420 } 421 } 422 423 /** 424 * java.lang.String#getBytes(int, int, byte[], int) 425 */ 426 @SuppressWarnings("deprecation") 427 public void test_getBytesII$BI() { 428 // Test for method void java.lang.String.getBytes(int, int, byte [], 429 // int) 430 byte[] buf = new byte[5]; 431 "Hello World".getBytes(6, 11, buf, 0); 432 assertEquals("Returned incorrect bytes", "World", new String(buf)); 433 434 try { 435 "Hello World".getBytes(-1, 1, null, 0); 436 fail("Expected StringIndexOutOfBoundsException"); 437 } catch (StringIndexOutOfBoundsException e) { 438 } catch (NullPointerException e) { 439 fail("Threw wrong exception"); 440 } 441 } 442 443 /** 444 * java.lang.String#getBytes(java.lang.String) 445 */ 446 public void test_getBytesLjava_lang_String() throws Exception { 447 // Test for method byte [] java.lang.String.getBytes(java.lang.String) 448 byte[] buf = "Hello World".getBytes(); 449 assertEquals("Returned incorrect bytes", "Hello World", new String(buf)); 450 451 try { 452 "string".getBytes("8849_1"); 453 fail("No UnsupportedEncodingException"); 454 } catch (UnsupportedEncodingException e) { 455 } 456 457 byte[] bytes = "\u3048".getBytes("UTF-8"); 458 byte[] expected = new byte[] { (byte) 0xE3, (byte) 0x81, (byte) 0x88 }; 459 assertEquals(expected[0], bytes[0]); 460 assertEquals(expected[1], bytes[1]); 461 assertEquals(expected[2], bytes[2]); 462 463 // Regression for HARMONY-663 464 try { 465 "string".getBytes("?Q?D??_??_6ffa?+vG?_??\u951f\ufffd??"); 466 fail("No UnsupportedEncodingException"); 467 } catch (UnsupportedEncodingException e) { 468 // expected 469 } 470 471 bytes = "-".getBytes("UTF-16"); 472 expected = new byte[] { (byte) 0xff, (byte) 0xfe }; 473 assertEquals(expected[0], bytes[0]); 474 assertEquals(expected[1], bytes[1]); 475 476 byte[] bytes2 = "-".getBytes("UTF-16LE"); 477 assertEquals(bytes2[0], bytes[2]); 478 assertEquals(bytes2[1], bytes[3]); 479 } 480 481 /* 482 * java.lang.String#getBytes() 483 */ 484 public void test_getBytes_NPE() throws Exception { 485 try { 486 "abc".getBytes((String) null); 487 fail("Should throw NullPointerException"); 488 } catch (UnsupportedEncodingException whatTheRiDocumentsAndWeThrow) { 489 } catch (NullPointerException whatTheRiActuallyThrows) { 490 } 491 492 try { 493 "Hello World".getBytes(1, 2, null, 1); 494 fail("Should throw NullPointerException"); 495 } catch (NullPointerException e) { 496 // Expected 497 } 498 } 499 500 /** 501 * java.lang.String#getChars(int, int, char[], int) 502 */ 503 public void test_getCharsII$CI() { 504 // Test for method void java.lang.String.getChars(int, int, char [], 505 // int) 506 hw1.getChars(5, hw1.length(), rbuf, 0); 507 508 for (int i = 0; i < rbuf.length; i++) 509 assertTrue("getChars returned incorrect char(s)", rbuf[i] == buf[i]); 510 } 511 512 /** 513 * java.lang.String#hashCode() 514 */ 515 public void test_hashCode() { 516 // Test for method int java.lang.String.hashCode() 517 int hwHashCode = 0; 518 final int hwLength = hw1.length(); 519 int powerOfThirtyOne = 1; 520 for (int counter = hwLength - 1; counter >= 0; counter--) { 521 hwHashCode += hw1.charAt(counter) * powerOfThirtyOne; 522 powerOfThirtyOne *= 31; 523 } 524 assertEquals("String did not hash to correct value", hwHashCode, hw1.hashCode()); 525 assertEquals("The empty string \"\" did not hash to zero", 0, "".hashCode()); 526 assertEquals("Calculated wrong string hashcode", -1933545242, "Harmony".hashCode()); 527 } 528 529 /** 530 * java.lang.String#indexOf(int) 531 */ 532 public void test_indexOfI() { 533 // Test for method int java.lang.String.indexOf(int) 534 assertEquals("Invalid index returned", 1, hw1.indexOf('e')); 535 assertEquals("Invalid index returned", 1, "a\ud800\udc00".indexOf(0x10000)); 536 } 537 538 /** 539 * java.lang.String#indexOf(int, int) 540 */ 541 public void test_indexOfII() { 542 // Test for method int java.lang.String.indexOf(int, int) 543 assertEquals("Invalid character index returned", 5, hw1.indexOf('W', 2)); 544 assertEquals("Invalid index returned", 2, "ab\ud800\udc00".indexOf(0x10000, 1)); 545 } 546 547 /** 548 * java.lang.String#indexOf(java.lang.String) 549 */ 550 public void test_indexOfLjava_lang_String() { 551 // Test for method int java.lang.String.indexOf(java.lang.String) 552 assertTrue("Failed to find string", hw1.indexOf("World") > 0); 553 assertTrue("Failed to find string", !(hw1.indexOf("ZZ") > 0)); 554 } 555 556 /** 557 * java.lang.String#indexOf(java.lang.String, int) 558 */ 559 public void test_indexOfLjava_lang_StringI() { 560 // Test for method int java.lang.String.indexOf(java.lang.String, int) 561 assertTrue("Failed to find string", hw1.indexOf("World", 0) > 0); 562 assertTrue("Found string outside index", !(hw1.indexOf("Hello", 6) > 0)); 563 assertEquals("Did not accept valid negative starting position", 0, 564 hello1.indexOf("", -5)); 565 assertEquals("Reported wrong error code", 5, hello1.indexOf("", 5)); 566 assertEquals("Wrong for empty in empty", 0, "".indexOf("", 0)); 567 } 568 569 /** 570 * java.lang.String#intern() 571 */ 572 public void test_intern() { 573 // Test for method java.lang.String java.lang.String.intern() 574 assertTrue("Intern returned incorrect result", hw1.intern() == hw2 575 .intern()); 576 } 577 578 /** 579 * java.lang.String#lastIndexOf(int) 580 */ 581 public void test_lastIndexOfI() { 582 // Test for method int java.lang.String.lastIndexOf(int) 583 assertEquals("Failed to return correct index", 5, hw1.lastIndexOf('W')); 584 assertEquals("Returned index for non-existent char", -1, hw1 585 .lastIndexOf('Z')); 586 assertEquals("Failed to return correct index", 1, "a\ud800\udc00" 587 .lastIndexOf(0x10000)); 588 } 589 590 /** 591 * java.lang.String#lastIndexOf(int, int) 592 */ 593 public void test_lastIndexOfII() { 594 // Test for method int java.lang.String.lastIndexOf(int, int) 595 assertEquals("Failed to return correct index", 5, hw1.lastIndexOf('W', 596 6)); 597 assertEquals("Returned index for char out of specified range", -1, hw1 598 .lastIndexOf('W', 4)); 599 assertEquals("Returned index for non-existent char", -1, hw1 600 .lastIndexOf('Z', 9)); 601 602 } 603 604 /** 605 * java.lang.String#lastIndexOf(java.lang.String) 606 */ 607 public void test_lastIndexOfLjava_lang_String() { 608 // Test for method int java.lang.String.lastIndexOf(java.lang.String) 609 assertEquals("Returned incorrect index", 5, hw1.lastIndexOf("World")); 610 assertEquals("Found String outside of index", -1, hw1 611 .lastIndexOf("HeKKKKKKKK")); 612 } 613 614 /** 615 * java.lang.String#lastIndexOf(java.lang.String, int) 616 */ 617 public void test_lastIndexOfLjava_lang_StringI() { 618 // Test for method int java.lang.String.lastIndexOf(java.lang.String, 619 // int) 620 assertEquals("Returned incorrect index", 5, hw1.lastIndexOf("World", 9)); 621 int result = hw1.lastIndexOf("Hello", 2); 622 assertTrue("Found String outside of index: " + result, result == 0); 623 assertEquals("Reported wrong error code", -1, hello1 624 .lastIndexOf("", -5)); 625 assertEquals("Did not accept valid large starting position", 5, hello1 626 .lastIndexOf("", 5)); 627 } 628 629 /** 630 * java.lang.String#length() 631 */ 632 public void test_length() { 633 // Test for method int java.lang.String.length() 634 assertEquals("Invalid length returned", 11, comp11.length()); 635 } 636 637 /** 638 * java.lang.String#regionMatches(int, java.lang.String, int, int) 639 */ 640 public void test_regionMatchesILjava_lang_StringII() { 641 // Test for method boolean java.lang.String.regionMatches(int, 642 // java.lang.String, int, int) 643 String bogusString = "xxcedkedkleiorem lvvwr e''' 3r3r 23r"; 644 645 assertTrue("identical regions failed comparison", hw1.regionMatches(2, 646 hw2, 2, 5)); 647 assertTrue("Different regions returned true", !hw1.regionMatches(2, 648 bogusString, 2, 5)); 649 } 650 651 /** 652 * java.lang.String#regionMatches(boolean, int, java.lang.String, 653 *int, int) 654 */ 655 public void test_regionMatchesZILjava_lang_StringII() { 656 // Test for method boolean java.lang.String.regionMatches(boolean, int, 657 // java.lang.String, int, int) 658 659 String bogusString = "xxcedkedkleiorem lvvwr e''' 3r3r 23r"; 660 661 assertTrue("identical regions failed comparison", hw1.regionMatches( 662 false, 2, hw2, 2, 5)); 663 assertTrue("identical regions failed comparison with different cases", 664 hw1.regionMatches(true, 2, hw2, 2, 5)); 665 assertTrue("Different regions returned true", !hw1.regionMatches(true, 666 2, bogusString, 2, 5)); 667 assertTrue("identical regions failed comparison with different cases", 668 hw1.regionMatches(false, 2, hw2, 2, 5)); 669 } 670 671 /** 672 * java.lang.String#replace(char, char) 673 */ 674 public void test_replaceCC() { 675 // Test for method java.lang.String java.lang.String.replace(char, char) 676 assertEquals("Failed replace", "HezzoWorzd", hw1.replace('l', 'z')); 677 } 678 679 /** 680 * java.lang.String#replace(CharSequence, CharSequence) 681 */ 682 public void test_replaceLjava_langCharSequenceLjava_langCharSequence() { 683 assertEquals("Failed replace", "aaccdd", "aabbdd".replace( 684 new StringBuffer("bb"), "cc")); 685 assertEquals("Failed replace by bigger seq", "cccbccc", "aba".replace( 686 "a", "ccc")); 687 assertEquals("Failed replace by smaller seq", "$bba^", "$aaaaa^" 688 .replace(new StringBuilder("aa"), "b")); 689 assertEquals("Failed to replace empty string", "%%a%%b%%c%%", 690 "abc".replace("", "%%")); 691 assertEquals("Failed to replace with empty string", "aacc", 692 "aabbcc".replace("b", "")); 693 assertEquals("Failed to replace in empty string", "abc", 694 "".replace("", "abc")); 695 } 696 697 /** 698 * java.lang.String#startsWith(java.lang.String) 699 */ 700 public void test_startsWithLjava_lang_String() { 701 // Test for method boolean java.lang.String.startsWith(java.lang.String) 702 assertTrue("Failed to find string", hw1.startsWith("Hello")); 703 assertTrue("Found incorrect string", !hw1.startsWith("T")); 704 } 705 706 /** 707 * java.lang.String#startsWith(java.lang.String, int) 708 */ 709 public void test_startsWithLjava_lang_StringI() { 710 // Test for method boolean java.lang.String.startsWith(java.lang.String, 711 // int) 712 assertTrue("Failed to find string", hw1.startsWith("World", 5)); 713 assertTrue("Found incorrect string", !hw1.startsWith("Hello", 5)); 714 } 715 716 /** 717 * java.lang.String#substring(int) 718 */ 719 public void test_substringI() { 720 // Test for method java.lang.String java.lang.String.substring(int) 721 assertEquals("Incorrect substring returned", "World", hw1.substring(5)); 722 assertTrue("not identical", hw1.substring(0) == hw1); 723 } 724 725 /** 726 * java.lang.String#substring(int, int) 727 */ 728 public void test_substringII() { 729 // Test for method java.lang.String java.lang.String.substring(int, int) 730 assertTrue("Incorrect substring returned", hw1.substring(0, 5).equals( 731 "Hello") 732 && (hw1.substring(5, 10).equals("World"))); 733 assertTrue("not identical", hw1.substring(0, hw1.length()) == hw1); 734 } 735 736 /** 737 * java.lang.String#substring(int, int) 738 */ 739 public void test_substringErrorMessage() { 740 try { 741 hw1.substring(-1, 1); 742 } catch (StringIndexOutOfBoundsException ex) { 743 String msg = ex.getMessage(); 744 assertTrue("Expected message to contain -1: " + msg, msg 745 .indexOf("-1") != -1); 746 } 747 try { 748 hw1.substring(4, 1); 749 } catch (StringIndexOutOfBoundsException ex) { 750 String msg = ex.getMessage(); 751 assertTrue("Expected message to contain -3: " + msg, msg 752 .indexOf("-3") != -1); 753 } 754 try { 755 hw1.substring(0, 100); 756 } catch (StringIndexOutOfBoundsException ex) { 757 String msg = ex.getMessage(); 758 assertTrue("Expected message to contain 100: " + msg, msg 759 .indexOf("100") != -1); 760 } 761 } 762 763 /** 764 * java.lang.String#toCharArray() 765 */ 766 public void test_toCharArray() { 767 // Test for method char [] java.lang.String.toCharArray() 768 769 String s = new String(buf, 0, buf.length); 770 char[] schars = s.toCharArray(); 771 for (int i = 0; i < s.length(); i++) 772 assertTrue("Returned incorrect char aray", buf[i] == schars[i]); 773 } 774 775 /** 776 * java.lang.String#toLowerCase() 777 */ 778 public void test_toLowerCase() { 779 // Test for method java.lang.String java.lang.String.toLowerCase() 780 assertTrue("toLowerCase case conversion did not succeed", hwuc 781 .toLowerCase().equals(hwlc)); 782 783 assertEquals( 784 "a) Sigma has ordinary lower case value when isolated with Unicode 4.0", 785 "\u03c3", "\u03a3".toLowerCase()); 786 assertEquals( 787 "b) Sigma has final form lower case value at end of word with Unicode 4.0", 788 "a\u03c2", "a\u03a3".toLowerCase()); 789 790 assertEquals("toLowerCase case conversion did not succeed", 791 "\uD801\uDC44", "\uD801\uDC1C".toLowerCase()); 792 } 793 794 /** 795 * java.lang.String#toLowerCase(java.util.Locale) 796 */ 797 public void test_toLowerCaseLjava_util_Locale() { 798 // Test for method java.lang.String 799 // java.lang.String.toLowerCase(java.util.Locale) 800 assertTrue("toLowerCase case conversion did not succeed", hwuc 801 .toLowerCase(java.util.Locale.getDefault()).equals(hwlc)); 802 assertEquals("Invalid \\u0049 for English", "\u0069", "\u0049" 803 .toLowerCase(Locale.ENGLISH)); 804 assertEquals("Invalid \\u0049 for Turkish", "\u0131", "\u0049" 805 .toLowerCase(new Locale("tr", ""))); 806 } 807 808 /** 809 * java.lang.String#toString() 810 */ 811 public void test_toString() { 812 // Test for method java.lang.String java.lang.String.toString() 813 assertTrue("Incorrect string returned", hw1.toString().equals(hw1)); 814 } 815 816 /** 817 * java.lang.String#toUpperCase() 818 */ 819 public void test_toUpperCase() { 820 // Test for method java.lang.String java.lang.String.toUpperCase() 821 assertTrue("Returned string is not UpperCase", hwlc.toUpperCase() 822 .equals(hwuc)); 823 824 assertEquals("Wrong conversion", "SS", "\u00df".toUpperCase()); 825 826 String s = "a\u00df\u1f56"; 827 assertTrue("Invalid conversion", !s.toUpperCase().equals(s)); 828 829 assertEquals("toUpperCase case conversion did not succeed", 830 "\uD801\uDC1C", "\uD801\uDC44".toUpperCase()); 831 } 832 833 /** 834 * java.lang.String#toUpperCase(java.util.Locale) 835 */ 836 public void test_toUpperCaseLjava_util_Locale() { 837 // Test for method java.lang.String 838 // java.lang.String.toUpperCase(java.util.Locale) 839 assertTrue("Returned string is not UpperCase", hwlc.toUpperCase() 840 .equals(hwuc)); 841 assertEquals("Invalid \\u0069 for English", "\u0049", "\u0069" 842 .toUpperCase(Locale.ENGLISH)); 843 assertEquals("Invalid \\u0069 for Turkish", "\u0130", "\u0069" 844 .toUpperCase(new Locale("tr", ""))); 845 } 846 847 /** 848 * java.lang.String#toUpperCase(java.util.Locale) 849 */ 850 public void test_toUpperCaseLjava_util_Locale_subtest0() { 851 // Test for method java.lang.String 852 // java.lang.String.toUpperCase(java.util.Locale) 853 } 854 855 /** 856 * java.lang.String#trim() 857 */ 858 public void test_trim() { 859 // Test for method java.lang.String java.lang.String.trim() 860 assertTrue("Incorrect string returned", " HelloWorld ".trim().equals( 861 hw1)); 862 } 863 864 /** 865 * java.lang.String#valueOf(char[]) 866 */ 867 public void test_valueOf$C() { 868 // Test for method java.lang.String java.lang.String.valueOf(char []) 869 assertEquals("Returned incorrect String", "World", String.valueOf(buf)); 870 } 871 872 /** 873 * java.lang.String#valueOf(char[], int, int) 874 */ 875 public void test_valueOf$CII() { 876 // Test for method java.lang.String java.lang.String.valueOf(char [], 877 // int, int) 878 char[] t = { 'H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd' }; 879 assertEquals("copyValueOf returned incorrect String", "World", String 880 .valueOf(t, 5, 5)); 881 } 882 883 /** 884 * java.lang.String#valueOf(char) 885 */ 886 public void test_valueOfC() { 887 // Test for method java.lang.String java.lang.String.valueOf(char) 888 for (int i = 0; i < 65536; i++) 889 assertTrue("Incorrect valueOf(char) returned: " + i, String 890 .valueOf((char) i).charAt(0) == (char) i); 891 } 892 893 /** 894 * java.lang.String#valueOf(double) 895 */ 896 public void test_valueOfD() { 897 // Test for method java.lang.String java.lang.String.valueOf(double) 898 assertEquals("Incorrect double string returned", 899 "1.7976931348623157E308", String.valueOf(Double.MAX_VALUE)); 900 } 901 902 /** 903 * java.lang.String#valueOf(float) 904 */ 905 public void test_valueOfF() { 906 // Test for method java.lang.String java.lang.String.valueOf(float) 907 assertTrue("incorrect float string returned--got: " 908 + String.valueOf(1.0F) + " wanted: 1.0", String.valueOf(1.0F) 909 .equals("1.0")); 910 assertTrue("incorrect float string returned--got: " 911 + String.valueOf(0.9F) + " wanted: 0.9", String.valueOf(0.9F) 912 .equals("0.9")); 913 assertTrue("incorrect float string returned--got: " 914 + String.valueOf(109.567F) + " wanted: 109.567", String 915 .valueOf(109.567F).equals("109.567")); 916 } 917 918 /** 919 * java.lang.String#valueOf(int) 920 */ 921 public void test_valueOfI() { 922 // Test for method java.lang.String java.lang.String.valueOf(int) 923 assertEquals("returned invalid int string", "1", String.valueOf(1)); 924 } 925 926 /** 927 * java.lang.String#valueOf(long) 928 */ 929 public void test_valueOfJ() { 930 // Test for method java.lang.String java.lang.String.valueOf(long) 931 assertEquals("returned incorrect long string", "927654321098", String 932 .valueOf(927654321098L)); 933 } 934 935 /** 936 * java.lang.String#valueOf(java.lang.Object) 937 */ 938 public void test_valueOfLjava_lang_Object() { 939 // Test for method java.lang.String 940 // java.lang.String.valueOf(java.lang.Object) 941 assertTrue("Incorrect Object string returned", obj.toString().equals( 942 String.valueOf(obj))); 943 } 944 945 /** 946 * java.lang.String#valueOf(boolean) 947 */ 948 public void test_valueOfZ() { 949 // Test for method java.lang.String java.lang.String.valueOf(boolean) 950 assertTrue("Incorrect boolean string returned", String.valueOf(false) 951 .equals("false") 952 && (String.valueOf(true).equals("true"))); 953 } 954 955 /** 956 * java.lang.String#contentEquals(CharSequence cs) 957 */ 958 public void test_contentEqualsLjava_lang_CharSequence() { 959 // Test for method java.lang.String 960 // java.lang.String.contentEquals(CharSequence cs) 961 assertFalse("Incorrect result of compare", "qwerty".contentEquals("")); 962 } 963 964 /** 965 * java.lang.String#format(Locale, String, Object[]) 966 */ 967 @SuppressWarnings("boxing") 968 public void test_format() { 969 assertEquals("13% of sum is 0x11", String.format("%d%% of %s is 0x%x", 970 13, "sum", 17)); 971 assertEquals("empty format", "", String.format("", 123, this)); 972 try { 973 String.format(null); 974 fail("NPE is expected on null format"); 975 } catch (NullPointerException ok) { 976 } 977 } 978} 979