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