1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package org.apache.harmony.tests.java.lang; 18 19import java.util.Properties; 20 21import junit.framework.TestCase; 22 23public class IntegerTest extends TestCase { 24 private Properties orgProps; 25 26 @Override 27 protected void setUp() { 28 orgProps = System.getProperties(); 29 } 30 31 @Override 32 protected void tearDown() { 33 System.setProperties(orgProps); 34 } 35 36 /** 37 * java.lang.Integer#byteValue() 38 */ 39 public void test_byteValue() { 40 // Test for method byte java.lang.Integer.byteValue() 41 assertEquals("Returned incorrect byte value", -1, new Integer(65535) 42 .byteValue()); 43 assertEquals("Returned incorrect byte value", 127, new Integer(127) 44 .byteValue()); 45 } 46 47 /** 48 * java.lang.Integer#compareTo(java.lang.Integer) 49 */ 50 public void test_compareToLjava_lang_Integer() { 51 // Test for method int java.lang.Integer.compareTo(java.lang.Integer) 52 assertTrue("-2 compared to 1 gave non-negative answer", new Integer(-2) 53 .compareTo(new Integer(1)) < 0); 54 assertEquals("-2 compared to -2 gave non-zero answer", 0, new Integer(-2) 55 .compareTo(new Integer(-2))); 56 assertTrue("3 compared to 2 gave non-positive answer", new Integer(3) 57 .compareTo(new Integer(2)) > 0); 58 59 try { 60 new Integer(0).compareTo(null); 61 fail("No NPE"); 62 } catch (NullPointerException e) { 63 } 64 } 65 66 /** 67 * java.lang.Integer#decode(java.lang.String) 68 */ 69 public void test_decodeLjava_lang_String2() { 70 // Test for method java.lang.Integer 71 // java.lang.Integer.decode(java.lang.String) 72 assertEquals("Failed for 132233", 73 132233, Integer.decode("132233").intValue()); 74 assertEquals("Failed for 07654321", 75 07654321, Integer.decode("07654321").intValue()); 76 assertTrue("Failed for #1234567", 77 Integer.decode("#1234567").intValue() == 0x1234567); 78 assertTrue("Failed for 0xdAd", 79 Integer.decode("0xdAd").intValue() == 0xdad); 80 assertEquals("Failed for -23", -23, Integer.decode("-23").intValue()); 81 assertEquals("Returned incorrect value for 0 decimal", 0, Integer 82 .decode("0").intValue()); 83 assertEquals("Returned incorrect value for 0 hex", 0, Integer.decode("0x0") 84 .intValue()); 85 assertTrue("Returned incorrect value for most negative value decimal", 86 Integer.decode("-2147483648").intValue() == 0x80000000); 87 assertTrue("Returned incorrect value for most negative value hex", 88 Integer.decode("-0x80000000").intValue() == 0x80000000); 89 assertTrue("Returned incorrect value for most positive value decimal", 90 Integer.decode("2147483647").intValue() == 0x7fffffff); 91 assertTrue("Returned incorrect value for most positive value hex", 92 Integer.decode("0x7fffffff").intValue() == 0x7fffffff); 93 94 boolean exception = false; 95 try { 96 Integer.decode("0a"); 97 } catch (NumberFormatException e) { 98 // correct 99 exception = true; 100 } 101 assertTrue("Failed to throw NumberFormatException for \"Oa\"", 102 exception); 103 104 exception = false; 105 try { 106 Integer.decode("2147483648"); 107 } catch (NumberFormatException e) { 108 // Correct 109 exception = true; 110 } 111 assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); 112 113 exception = false; 114 try { 115 Integer.decode("-2147483649"); 116 } catch (NumberFormatException e) { 117 // Correct 118 exception = true; 119 } 120 assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); 121 122 exception = false; 123 try { 124 Integer.decode("0x80000000"); 125 } catch (NumberFormatException e) { 126 // Correct 127 exception = true; 128 } 129 assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); 130 131 exception = false; 132 try { 133 Integer.decode("-0x80000001"); 134 } catch (NumberFormatException e) { 135 // Correct 136 exception = true; 137 } 138 assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception); 139 140 exception = false; 141 try { 142 Integer.decode("9999999999"); 143 } catch (NumberFormatException e) { 144 // Correct 145 exception = true; 146 } 147 assertTrue("Failed to throw exception for 9999999999", exception); 148 149 try { 150 Integer.decode("-"); 151 fail("Expected exception for -"); 152 } catch (NumberFormatException e) { 153 // Expected 154 } 155 156 try { 157 Integer.decode("0x"); 158 fail("Expected exception for 0x"); 159 } catch (NumberFormatException e) { 160 // Expected 161 } 162 163 try { 164 Integer.decode("#"); 165 fail("Expected exception for #"); 166 } catch (NumberFormatException e) { 167 // Expected 168 } 169 170 try { 171 Integer.decode("x123"); 172 fail("Expected exception for x123"); 173 } catch (NumberFormatException e) { 174 // Expected 175 } 176 177 try { 178 Integer.decode(null); 179 fail("Expected exception for null"); 180 } catch (NullPointerException e) { 181 // Expected 182 } 183 184 try { 185 Integer.decode(""); 186 fail("Expected exception for empty string"); 187 } catch (NumberFormatException ex) { 188 // Expected 189 } 190 191 try { 192 Integer.decode(" "); 193 fail("Expected exception for single space"); 194 } catch (NumberFormatException ex) { 195 // Expected 196 } 197 198 } 199 200 /** 201 * java.lang.Integer#doubleValue() 202 */ 203 public void test_doubleValue2() { 204 // Test for method double java.lang.Integer.doubleValue() 205 assertEquals("Returned incorrect double value", 2147483647.0, new Integer(2147483647) 206 .doubleValue(), 0.0D); 207 assertEquals("Returned incorrect double value", -2147483647.0, new Integer(-2147483647) 208 .doubleValue(), 0.0D); 209 } 210 211 /** 212 * java.lang.Integer#equals(java.lang.Object) 213 */ 214 public void test_equalsLjava_lang_Object2() { 215 // Test for method boolean java.lang.Integer.equals(java.lang.Object) 216 Integer i1 = new Integer(1000); 217 Integer i2 = new Integer(1000); 218 Integer i3 = new Integer(-1000); 219 assertTrue("Equality test failed", i1.equals(i2) && !(i1.equals(i3))); 220 } 221 222 /** 223 * java.lang.Integer#floatValue() 224 */ 225 public void test_floatValue2() { 226 // Test for method float java.lang.Integer.floatValue() 227 assertTrue("Returned incorrect float value", new Integer(65535) 228 .floatValue() == 65535.0f); 229 assertTrue("Returned incorrect float value", new Integer(-65535) 230 .floatValue() == -65535.0f); 231 } 232 233 /** 234 * java.lang.Integer#getInteger(java.lang.String) 235 */ 236 public void test_getIntegerLjava_lang_String() { 237 // Test for method java.lang.Integer 238 // java.lang.Integer.getInteger(java.lang.String) 239 Properties tProps = new Properties(); 240 tProps.put("testInt", "99"); 241 System.setProperties(tProps); 242 assertTrue("returned incorrect Integer", Integer.getInteger("testInt") 243 .equals(new Integer(99))); 244 assertNull("returned incorrect default Integer", Integer 245 .getInteger("ff")); 246 } 247 248 /** 249 * java.lang.Integer#getInteger(java.lang.String, int) 250 */ 251 public void test_getIntegerLjava_lang_StringI() { 252 // Test for method java.lang.Integer 253 // java.lang.Integer.getInteger(java.lang.String, int) 254 Properties tProps = new Properties(); 255 tProps.put("testInt", "99"); 256 System.setProperties(tProps); 257 assertTrue("returned incorrect Integer", Integer.getInteger("testInt", 258 4).equals(new Integer(99))); 259 assertTrue("returned incorrect default Integer", Integer.getInteger( 260 "ff", 4).equals(new Integer(4))); 261 } 262 263 /** 264 * java.lang.Integer#getInteger(java.lang.String, java.lang.Integer) 265 */ 266 public void test_getIntegerLjava_lang_StringLjava_lang_Integer() { 267 // Test for method java.lang.Integer 268 // java.lang.Integer.getInteger(java.lang.String, java.lang.Integer) 269 Properties tProps = new Properties(); 270 tProps.put("testInt", "99"); 271 System.setProperties(tProps); 272 assertTrue("returned incorrect Integer", Integer.getInteger("testInt", 273 new Integer(4)).equals(new Integer(99))); 274 assertTrue("returned incorrect default Integer", Integer.getInteger( 275 "ff", new Integer(4)).equals(new Integer(4))); 276 } 277 278 /** 279 * java.lang.Integer#hashCode() 280 */ 281 public void test_hashCode2() { 282 // Test for method int java.lang.Integer.hashCode() 283 284 Integer i1 = new Integer(1000); 285 Integer i2 = new Integer(-1000); 286 assertTrue("Returned incorrect hashcode", i1.hashCode() == 1000 287 && (i2.hashCode() == -1000)); 288 } 289 290 /** 291 * java.lang.Integer#intValue() 292 */ 293 public void test_intValue2() { 294 // Test for method int java.lang.Integer.intValue() 295 296 Integer i = new Integer(8900); 297 assertEquals("Returned incorrect int value", 8900, i.intValue()); 298 } 299 300 /** 301 * java.lang.Integer#longValue() 302 */ 303 public void test_longValue2() { 304 // Test for method long java.lang.Integer.longValue() 305 Integer i = new Integer(8900); 306 assertEquals("Returned incorrect long value", 8900L, i.longValue()); 307 } 308 309 /** 310 * java.lang.Integer#parseInt(java.lang.String) 311 */ 312 public void test_parseIntLjava_lang_String2() { 313 // Test for method int java.lang.Integer.parseInt(java.lang.String) 314 315 int i = Integer.parseInt("-8900"); 316 assertEquals("Returned incorrect int", -8900, i); 317 assertEquals("Returned incorrect value for 0", 0, Integer.parseInt("0")); 318 assertTrue("Returned incorrect value for most negative value", Integer 319 .parseInt("-2147483648") == 0x80000000); 320 assertTrue("Returned incorrect value for most positive value", Integer 321 .parseInt("2147483647") == 0x7fffffff); 322 323 boolean exception = false; 324 try { 325 Integer.parseInt("999999999999"); 326 } catch (NumberFormatException e) { 327 // Correct 328 exception = true; 329 } 330 assertTrue("Failed to throw exception for value > int", exception); 331 332 exception = false; 333 try { 334 Integer.parseInt("2147483648"); 335 } catch (NumberFormatException e) { 336 // Correct 337 exception = true; 338 } 339 assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); 340 341 exception = false; 342 try { 343 Integer.parseInt("-2147483649"); 344 } catch (NumberFormatException e) { 345 // Correct 346 exception = true; 347 } 348 assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); 349 } 350 351 /** 352 * java.lang.Integer#parseInt(java.lang.String, int) 353 */ 354 public void test_parseIntLjava_lang_StringI2() { 355 // Test for method int java.lang.Integer.parseInt(java.lang.String, int) 356 assertEquals("Parsed dec val incorrectly", 357 -8000, Integer.parseInt("-8000", 10)); 358 assertEquals("Parsed hex val incorrectly", 359 255, Integer.parseInt("FF", 16)); 360 assertEquals("Parsed oct val incorrectly", 361 16, Integer.parseInt("20", 8)); 362 assertEquals("Returned incorrect value for 0 hex", 0, Integer.parseInt("0", 363 16)); 364 assertTrue("Returned incorrect value for most negative value hex", 365 Integer.parseInt("-80000000", 16) == 0x80000000); 366 assertTrue("Returned incorrect value for most positive value hex", 367 Integer.parseInt("7fffffff", 16) == 0x7fffffff); 368 assertEquals("Returned incorrect value for 0 decimal", 0, Integer.parseInt( 369 "0", 10)); 370 assertTrue("Returned incorrect value for most negative value decimal", 371 Integer.parseInt("-2147483648", 10) == 0x80000000); 372 assertTrue("Returned incorrect value for most positive value decimal", 373 Integer.parseInt("2147483647", 10) == 0x7fffffff); 374 375 boolean exception = false; 376 try { 377 Integer.parseInt("FFFF", 10); 378 } catch (NumberFormatException e) { 379 // Correct 380 exception = true; 381 } 382 assertTrue( 383 "Failed to throw exception when passes hex string and dec parm", 384 exception); 385 386 exception = false; 387 try { 388 Integer.parseInt("2147483648", 10); 389 } catch (NumberFormatException e) { 390 // Correct 391 exception = true; 392 } 393 assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); 394 395 exception = false; 396 try { 397 Integer.parseInt("-2147483649", 10); 398 } catch (NumberFormatException e) { 399 // Correct 400 exception = true; 401 } 402 assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); 403 404 exception = false; 405 try { 406 Integer.parseInt("80000000", 16); 407 } catch (NumberFormatException e) { 408 // Correct 409 exception = true; 410 } 411 assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); 412 413 exception = false; 414 try { 415 Integer.parseInt("-80000001", 16); 416 } catch (NumberFormatException e) { 417 // Correct 418 exception = true; 419 } 420 assertTrue("Failed to throw exception for hex MIN_VALUE + 1", exception); 421 422 exception = false; 423 try { 424 Integer.parseInt("9999999999", 10); 425 } catch (NumberFormatException e) { 426 // Correct 427 exception = true; 428 } 429 assertTrue("Failed to throw exception for 9999999999", exception); 430 } 431 432 /** 433 * java.lang.Integer#shortValue() 434 */ 435 public void test_shortValue2() { 436 // Test for method short java.lang.Integer.shortValue() 437 Integer i = new Integer(2147450880); 438 assertEquals("Returned incorrect long value", -32768, i.shortValue()); 439 } 440 441 /** 442 * java.lang.Integer#toBinaryString(int) 443 */ 444 public void test_toBinaryStringI() { 445 // Test for method java.lang.String 446 // java.lang.Integer.toBinaryString(int) 447 assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toBinaryString( 448 Integer.MAX_VALUE)); 449 assertEquals("Incorrect string returned", "10000000000000000000000000000000", Integer.toBinaryString( 450 Integer.MIN_VALUE)); 451 } 452 453 /** 454 * java.lang.Integer#toHexString(int) 455 */ 456 public void test_toHexStringI() { 457 // Test for method java.lang.String java.lang.Integer.toHexString(int) 458 459 String[] hexvals = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 460 "a", "b", "c", "d", "e", "f" }; 461 462 for (int i = 0; i < 16; i++) { 463 assertTrue("Incorrect string returned " + hexvals[i], Integer 464 .toHexString(i).equals(hexvals[i])); 465 } 466 467 assertTrue("Returned incorrect hex string: " 468 + Integer.toHexString(Integer.MAX_VALUE), Integer.toHexString( 469 Integer.MAX_VALUE).equals("7fffffff")); 470 assertTrue("Returned incorrect hex string: " 471 + Integer.toHexString(Integer.MIN_VALUE), Integer.toHexString( 472 Integer.MIN_VALUE).equals("80000000")); 473 } 474 475 /** 476 * java.lang.Integer#toOctalString(int) 477 */ 478 public void test_toOctalStringI() { 479 // Test for method java.lang.String java.lang.Integer.toOctalString(int) 480 // Spec states that the int arg is treated as unsigned 481 assertEquals("Returned incorrect octal string", "17777777777", Integer.toOctalString( 482 Integer.MAX_VALUE)); 483 assertEquals("Returned incorrect octal string", "20000000000", Integer.toOctalString( 484 Integer.MIN_VALUE)); 485 } 486 487 /** 488 * java.lang.Integer#toString() 489 */ 490 public void test_toString2() { 491 // Test for method java.lang.String java.lang.Integer.toString() 492 493 Integer i = new Integer(-80001); 494 495 assertEquals("Returned incorrect String", "-80001", i.toString()); 496 } 497 498 /** 499 * java.lang.Integer#toString(int) 500 */ 501 public void test_toStringI2() { 502 // Test for method java.lang.String java.lang.Integer.toString(int) 503 504 assertEquals("Returned incorrect String", "-80765", Integer.toString(-80765) 505 ); 506 assertEquals("Returned incorrect octal string", "2147483647", Integer.toString( 507 Integer.MAX_VALUE)); 508 assertEquals("Returned incorrect octal string", "-2147483647", Integer.toString( 509 -Integer.MAX_VALUE)); 510 assertEquals("Returned incorrect octal string", "-2147483648", Integer.toString( 511 Integer.MIN_VALUE)); 512 513 // Test for HARMONY-6068 514 assertEquals("Returned incorrect octal String", "-1000", Integer.toString(-1000)); 515 assertEquals("Returned incorrect octal String", "1000", Integer.toString(1000)); 516 assertEquals("Returned incorrect octal String", "0", Integer.toString(0)); 517 assertEquals("Returned incorrect octal String", "708", Integer.toString(708)); 518 assertEquals("Returned incorrect octal String", "-100", Integer.toString(-100)); 519 assertEquals("Returned incorrect octal String", "-1000000008", Integer.toString(-1000000008)); 520 assertEquals("Returned incorrect octal String", "2000000008", Integer.toString(2000000008)); 521 } 522 523 /** 524 * java.lang.Integer#toString(int, int) 525 */ 526 public void test_toStringII() { 527 // Test for method java.lang.String java.lang.Integer.toString(int, int) 528 assertEquals("Returned incorrect octal string", "17777777777", Integer.toString( 529 2147483647, 8)); 530 assertTrue("Returned incorrect hex string--wanted 7fffffff but got: " 531 + Integer.toString(2147483647, 16), Integer.toString( 532 2147483647, 16).equals("7fffffff")); 533 assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toString(2147483647, 2) 534 ); 535 assertEquals("Incorrect string returned", "2147483647", Integer 536 .toString(2147483647, 10)); 537 538 assertEquals("Returned incorrect octal string", "-17777777777", Integer.toString( 539 -2147483647, 8)); 540 assertTrue("Returned incorrect hex string--wanted -7fffffff but got: " 541 + Integer.toString(-2147483647, 16), Integer.toString( 542 -2147483647, 16).equals("-7fffffff")); 543 assertEquals("Incorrect string returned", 544 "-1111111111111111111111111111111", Integer 545 .toString(-2147483647, 2)); 546 assertEquals("Incorrect string returned", "-2147483647", Integer.toString(-2147483647, 547 10)); 548 549 assertEquals("Returned incorrect octal string", "-20000000000", Integer.toString( 550 -2147483648, 8)); 551 assertTrue("Returned incorrect hex string--wanted -80000000 but got: " 552 + Integer.toString(-2147483648, 16), Integer.toString( 553 -2147483648, 16).equals("-80000000")); 554 assertEquals("Incorrect string returned", 555 "-10000000000000000000000000000000", Integer 556 .toString(-2147483648, 2)); 557 assertEquals("Incorrect string returned", "-2147483648", Integer.toString(-2147483648, 558 10)); 559 } 560 561 /** 562 * java.lang.Integer#valueOf(java.lang.String) 563 */ 564 public void test_valueOfLjava_lang_String2() { 565 // Test for method java.lang.Integer 566 // java.lang.Integer.valueOf(java.lang.String) 567 assertEquals("Returned incorrect int", 8888888, Integer.valueOf("8888888") 568 .intValue()); 569 assertTrue("Returned incorrect int", Integer.valueOf("2147483647") 570 .intValue() == Integer.MAX_VALUE); 571 assertTrue("Returned incorrect int", Integer.valueOf("-2147483648") 572 .intValue() == Integer.MIN_VALUE); 573 574 boolean exception = false; 575 try { 576 Integer.valueOf("2147483648"); 577 } catch (NumberFormatException e) { 578 // Correct 579 exception = true; 580 } 581 assertTrue("Failed to throw exception with MAX_VALUE + 1", exception); 582 583 exception = false; 584 try { 585 Integer.valueOf("-2147483649"); 586 } catch (NumberFormatException e) { 587 // Correct 588 exception = true; 589 } 590 assertTrue("Failed to throw exception with MIN_VALUE - 1", exception); 591 } 592 593 /** 594 * java.lang.Integer#valueOf(java.lang.String, int) 595 */ 596 public void test_valueOfLjava_lang_StringI2() { 597 // Test for method java.lang.Integer 598 // java.lang.Integer.valueOf(java.lang.String, int) 599 assertEquals("Returned incorrect int for hex string", 255, Integer.valueOf( 600 "FF", 16).intValue()); 601 assertEquals("Returned incorrect int for oct string", 16, Integer.valueOf( 602 "20", 8).intValue()); 603 assertEquals("Returned incorrect int for bin string", 4, Integer.valueOf( 604 "100", 2).intValue()); 605 606 assertEquals("Returned incorrect int for - hex string", -255, Integer.valueOf( 607 "-FF", 16).intValue()); 608 assertEquals("Returned incorrect int for - oct string", -16, Integer.valueOf( 609 "-20", 8).intValue()); 610 assertEquals("Returned incorrect int for - bin string", -4, Integer.valueOf( 611 "-100", 2).intValue()); 612 assertTrue("Returned incorrect int", Integer.valueOf("2147483647", 10) 613 .intValue() == Integer.MAX_VALUE); 614 assertTrue("Returned incorrect int", Integer.valueOf("-2147483648", 10) 615 .intValue() == Integer.MIN_VALUE); 616 assertTrue("Returned incorrect int", Integer.valueOf("7fffffff", 16) 617 .intValue() == Integer.MAX_VALUE); 618 assertTrue("Returned incorrect int", Integer.valueOf("-80000000", 16) 619 .intValue() == Integer.MIN_VALUE); 620 621 boolean exception = false; 622 try { 623 Integer.valueOf("FF", 2); 624 } catch (NumberFormatException e) { 625 // Correct 626 exception = true; 627 } 628 assertTrue( 629 "Failed to throw exception with hex string and base 2 radix", 630 exception); 631 632 exception = false; 633 try { 634 Integer.valueOf("2147483648", 10); 635 } catch (NumberFormatException e) { 636 // Correct 637 exception = true; 638 } 639 assertTrue("Failed to throw exception with MAX_VALUE + 1", exception); 640 641 exception = false; 642 try { 643 Integer.valueOf("-2147483649", 10); 644 } catch (NumberFormatException e) { 645 // Correct 646 exception = true; 647 } 648 assertTrue("Failed to throw exception with MIN_VALUE - 1", exception); 649 650 exception = false; 651 try { 652 Integer.valueOf("80000000", 16); 653 } catch (NumberFormatException e) { 654 // Correct 655 exception = true; 656 } 657 assertTrue("Failed to throw exception with hex MAX_VALUE + 1", 658 exception); 659 660 exception = false; 661 try { 662 Integer.valueOf("-80000001", 16); 663 } catch (NumberFormatException e) { 664 // Correct 665 exception = true; 666 } 667 assertTrue("Failed to throw exception with hex MIN_VALUE - 1", 668 exception); 669 } 670 671 /** 672 * java.lang.Integer#valueOf(byte) 673 */ 674 public void test_valueOfI() { 675 assertEquals(new Integer(Integer.MIN_VALUE), Integer.valueOf(Integer.MIN_VALUE)); 676 assertEquals(new Integer(Integer.MAX_VALUE), Integer.valueOf(Integer.MAX_VALUE)); 677 assertEquals(new Integer(0), Integer.valueOf(0)); 678 679 short s = -128; 680 while (s < 128) { 681 assertEquals(new Integer(s), Integer.valueOf(s)); 682 assertSame(Integer.valueOf(s), Integer.valueOf(s)); 683 s++; 684 } 685 } 686 687 /** 688 * java.lang.Integer#hashCode() 689 */ 690 public void test_hashCode() { 691 assertEquals(1, new Integer(1).hashCode()); 692 assertEquals(2, new Integer(2).hashCode()); 693 assertEquals(0, new Integer(0).hashCode()); 694 assertEquals(-1, new Integer(-1).hashCode()); 695 } 696 697 /** 698 * java.lang.Integer#Integer(String) 699 */ 700 public void test_ConstructorLjava_lang_String() { 701 assertEquals(new Integer(0), new Integer("0")); 702 assertEquals(new Integer(1), new Integer("1")); 703 assertEquals(new Integer(-1), new Integer("-1")); 704 705 try { 706 new Integer("0x1"); 707 fail("Expected NumberFormatException with hex string."); 708 } catch (NumberFormatException e) { 709 } 710 711 try { 712 new Integer("9.2"); 713 fail("Expected NumberFormatException with floating point string."); 714 } catch (NumberFormatException e) { 715 } 716 717 try { 718 new Integer(""); 719 fail("Expected NumberFormatException with empty string."); 720 } catch (NumberFormatException e) { 721 } 722 723 try { 724 new Integer(null); 725 fail("Expected NumberFormatException with null string."); 726 } catch (NumberFormatException e) { 727 } 728 } 729 730 /** 731 * java.lang.Integer#Integer 732 */ 733 public void test_ConstructorI() { 734 assertEquals(1, new Integer(1).intValue()); 735 assertEquals(2, new Integer(2).intValue()); 736 assertEquals(0, new Integer(0).intValue()); 737 assertEquals(-1, new Integer(-1).intValue()); 738 739 Integer i = new Integer(-89000); 740 assertEquals("Incorrect Integer created", -89000, i.intValue()); 741 } 742 743 /** 744 * java.lang.Integer#byteValue() 745 */ 746 public void test_booleanValue() { 747 assertEquals(1, new Integer(1).byteValue()); 748 assertEquals(2, new Integer(2).byteValue()); 749 assertEquals(0, new Integer(0).byteValue()); 750 assertEquals(-1, new Integer(-1).byteValue()); 751 } 752 753 /** 754 * java.lang.Integer#equals(Object) 755 */ 756 public void test_equalsLjava_lang_Object() { 757 assertEquals(new Integer(0), Integer.valueOf(0)); 758 assertEquals(new Integer(1), Integer.valueOf(1)); 759 assertEquals(new Integer(-1), Integer.valueOf(-1)); 760 761 Integer fixture = new Integer(25); 762 assertEquals(fixture, fixture); 763 assertFalse(fixture.equals(null)); 764 assertFalse(fixture.equals("Not a Integer")); 765 } 766 767 /** 768 * java.lang.Integer#toString() 769 */ 770 public void test_toString() { 771 assertEquals("-1", new Integer(-1).toString()); 772 assertEquals("0", new Integer(0).toString()); 773 assertEquals("1", new Integer(1).toString()); 774 assertEquals("-1", new Integer(0xFFFFFFFF).toString()); 775 } 776 777 /** 778 * java.lang.Integer#toString 779 */ 780 public void test_toStringI() { 781 assertEquals("-1", Integer.toString(-1)); 782 assertEquals("0", Integer.toString(0)); 783 assertEquals("1", Integer.toString(1)); 784 assertEquals("-1", Integer.toString(0xFFFFFFFF)); 785 } 786 787 /** 788 * java.lang.Integer#valueOf(String) 789 */ 790 public void test_valueOfLjava_lang_String() { 791 assertEquals(new Integer(0), Integer.valueOf("0")); 792 assertEquals(new Integer(1), Integer.valueOf("1")); 793 assertEquals(new Integer(-1), Integer.valueOf("-1")); 794 795 try { 796 Integer.valueOf("0x1"); 797 fail("Expected NumberFormatException with hex string."); 798 } catch (NumberFormatException e) { 799 } 800 801 try { 802 Integer.valueOf("9.2"); 803 fail("Expected NumberFormatException with floating point string."); 804 } catch (NumberFormatException e) { 805 } 806 807 try { 808 Integer.valueOf(""); 809 fail("Expected NumberFormatException with empty string."); 810 } catch (NumberFormatException e) { 811 } 812 813 try { 814 Integer.valueOf(null); 815 fail("Expected NumberFormatException with null string."); 816 } catch (NumberFormatException e) { 817 } 818 } 819 820 /** 821 * java.lang.Integer#valueOf(String, int) 822 */ 823 public void test_valueOfLjava_lang_StringI() { 824 assertEquals(new Integer(0), Integer.valueOf("0", 10)); 825 assertEquals(new Integer(1), Integer.valueOf("1", 10)); 826 assertEquals(new Integer(-1), Integer.valueOf("-1", 10)); 827 828 //must be consistent with Character.digit() 829 assertEquals(Character.digit('1', 2), Integer.valueOf("1", 2).byteValue()); 830 assertEquals(Character.digit('F', 16), Integer.valueOf("F", 16).byteValue()); 831 832 try { 833 Integer.valueOf("0x1", 10); 834 fail("Expected NumberFormatException with hex string."); 835 } catch (NumberFormatException e) { 836 } 837 838 try { 839 Integer.valueOf("9.2", 10); 840 fail("Expected NumberFormatException with floating point string."); 841 } catch (NumberFormatException e) { 842 } 843 844 try { 845 Integer.valueOf("", 10); 846 fail("Expected NumberFormatException with empty string."); 847 } catch (NumberFormatException e) { 848 } 849 850 try { 851 Integer.valueOf(null, 10); 852 fail("Expected NumberFormatException with null string."); 853 } catch (NumberFormatException e) { 854 } 855 } 856 857 /** 858 * java.lang.Integer#parseInt(String) 859 */ 860 public void test_parseIntLjava_lang_String() { 861 assertEquals(0, Integer.parseInt("0")); 862 assertEquals(1, Integer.parseInt("1")); 863 assertEquals(-1, Integer.parseInt("-1")); 864 865 try { 866 Integer.parseInt("0x1"); 867 fail("Expected NumberFormatException with hex string."); 868 } catch (NumberFormatException e) { 869 } 870 871 try { 872 Integer.parseInt("9.2"); 873 fail("Expected NumberFormatException with floating point string."); 874 } catch (NumberFormatException e) { 875 } 876 877 try { 878 Integer.parseInt(""); 879 fail("Expected NumberFormatException with empty string."); 880 } catch (NumberFormatException e) { 881 } 882 883 try { 884 Integer.parseInt(null); 885 fail("Expected NumberFormatException with null string."); 886 } catch (NumberFormatException e) { 887 } 888 } 889 890 /** 891 * java.lang.Integer#parseInt(String, int) 892 */ 893 public void test_parseIntLjava_lang_StringI() { 894 assertEquals(0, Integer.parseInt("0", 10)); 895 assertEquals(1, Integer.parseInt("1", 10)); 896 assertEquals(-1, Integer.parseInt("-1", 10)); 897 898 //must be consistent with Character.digit() 899 assertEquals(Character.digit('1', 2), Integer.parseInt("1", 2)); 900 assertEquals(Character.digit('F', 16), Integer.parseInt("F", 16)); 901 902 try { 903 Integer.parseInt("0x1", 10); 904 fail("Expected NumberFormatException with hex string."); 905 } catch (NumberFormatException e) { 906 } 907 908 try { 909 Integer.parseInt("9.2", 10); 910 fail("Expected NumberFormatException with floating point string."); 911 } catch (NumberFormatException e) { 912 } 913 914 try { 915 Integer.parseInt("", 10); 916 fail("Expected NumberFormatException with empty string."); 917 } catch (NumberFormatException e) { 918 } 919 920 try { 921 Integer.parseInt(null, 10); 922 fail("Expected NumberFormatException with null string."); 923 } catch (NumberFormatException e) { 924 } 925 } 926 927 /** 928 * java.lang.Integer#decode(String) 929 */ 930 public void test_decodeLjava_lang_String() { 931 assertEquals(new Integer(0), Integer.decode("0")); 932 assertEquals(new Integer(1), Integer.decode("1")); 933 assertEquals(new Integer(-1), Integer.decode("-1")); 934 assertEquals(new Integer(0xF), Integer.decode("0xF")); 935 assertEquals(new Integer(0xF), Integer.decode("#F")); 936 assertEquals(new Integer(0xF), Integer.decode("0XF")); 937 assertEquals(new Integer(07), Integer.decode("07")); 938 939 try { 940 Integer.decode("9.2"); 941 fail("Expected NumberFormatException with floating point string."); 942 } catch (NumberFormatException e) { 943 } 944 945 try { 946 Integer.decode(""); 947 fail("Expected NumberFormatException with empty string."); 948 } catch (NumberFormatException e) { 949 } 950 951 try { 952 Integer.decode(null); 953 //undocumented NPE, but seems consistent across JREs 954 fail("Expected NullPointerException with null string."); 955 } catch (NullPointerException e) { 956 } 957 } 958 959 /** 960 * java.lang.Integer#doubleValue() 961 */ 962 public void test_doubleValue() { 963 assertEquals(-1D, new Integer(-1).doubleValue(), 0D); 964 assertEquals(0D, new Integer(0).doubleValue(), 0D); 965 assertEquals(1D, new Integer(1).doubleValue(), 0D); 966 } 967 968 /** 969 * java.lang.Integer#floatValue() 970 */ 971 public void test_floatValue() { 972 assertEquals(-1F, new Integer(-1).floatValue(), 0F); 973 assertEquals(0F, new Integer(0).floatValue(), 0F); 974 assertEquals(1F, new Integer(1).floatValue(), 0F); 975 } 976 977 /** 978 * java.lang.Integer#intValue() 979 */ 980 public void test_intValue() { 981 assertEquals(-1, new Integer(-1).intValue()); 982 assertEquals(0, new Integer(0).intValue()); 983 assertEquals(1, new Integer(1).intValue()); 984 } 985 986 /** 987 * java.lang.Integer#longValue() 988 */ 989 public void test_longValue() { 990 assertEquals(-1L, new Integer(-1).longValue()); 991 assertEquals(0L, new Integer(0).longValue()); 992 assertEquals(1L, new Integer(1).longValue()); 993 } 994 995 /** 996 * java.lang.Integer#shortValue() 997 */ 998 public void test_shortValue() { 999 assertEquals(-1, new Integer(-1).shortValue()); 1000 assertEquals(0, new Integer(0).shortValue()); 1001 assertEquals(1, new Integer(1).shortValue()); 1002 } 1003 1004 /** 1005 * java.lang.Integer#highestOneBit(int) 1006 */ 1007 public void test_highestOneBitI() { 1008 assertEquals(0x08, Integer.highestOneBit(0x0A)); 1009 assertEquals(0x08, Integer.highestOneBit(0x0B)); 1010 assertEquals(0x08, Integer.highestOneBit(0x0C)); 1011 assertEquals(0x08, Integer.highestOneBit(0x0F)); 1012 assertEquals(0x80, Integer.highestOneBit(0xFF)); 1013 1014 assertEquals(0x080000, Integer.highestOneBit(0x0F1234)); 1015 assertEquals(0x800000, Integer.highestOneBit(0xFF9977)); 1016 1017 assertEquals(0x80000000, Integer.highestOneBit(0xFFFFFFFF)); 1018 1019 assertEquals(0, Integer.highestOneBit(0)); 1020 assertEquals(1, Integer.highestOneBit(1)); 1021 assertEquals(0x80000000, Integer.highestOneBit(-1)); 1022 } 1023 1024 /** 1025 * java.lang.Integer#lowestOneBit(int) 1026 */ 1027 public void test_lowestOneBitI() { 1028 assertEquals(0x10, Integer.lowestOneBit(0xF0)); 1029 1030 assertEquals(0x10, Integer.lowestOneBit(0x90)); 1031 assertEquals(0x10, Integer.lowestOneBit(0xD0)); 1032 1033 assertEquals(0x10, Integer.lowestOneBit(0x123490)); 1034 assertEquals(0x10, Integer.lowestOneBit(0x1234D0)); 1035 1036 assertEquals(0x100000, Integer.lowestOneBit(0x900000)); 1037 assertEquals(0x100000, Integer.lowestOneBit(0xD00000)); 1038 1039 assertEquals(0x40, Integer.lowestOneBit(0x40)); 1040 assertEquals(0x40, Integer.lowestOneBit(0xC0)); 1041 1042 assertEquals(0x4000, Integer.lowestOneBit(0x4000)); 1043 assertEquals(0x4000, Integer.lowestOneBit(0xC000)); 1044 1045 assertEquals(0x4000, Integer.lowestOneBit(0x99994000)); 1046 assertEquals(0x4000, Integer.lowestOneBit(0x9999C000)); 1047 1048 assertEquals(0, Integer.lowestOneBit(0)); 1049 assertEquals(1, Integer.lowestOneBit(1)); 1050 assertEquals(1, Integer.lowestOneBit(-1)); 1051 } 1052 1053 /** 1054 * java.lang.Integer#numberOfLeadingZeros(int) 1055 */ 1056 public void test_numberOfLeadingZerosI() { 1057 assertEquals(32, Integer.numberOfLeadingZeros(0x0)); 1058 assertEquals(31, Integer.numberOfLeadingZeros(0x1)); 1059 assertEquals(30, Integer.numberOfLeadingZeros(0x2)); 1060 assertEquals(30, Integer.numberOfLeadingZeros(0x3)); 1061 assertEquals(29, Integer.numberOfLeadingZeros(0x4)); 1062 assertEquals(29, Integer.numberOfLeadingZeros(0x5)); 1063 assertEquals(29, Integer.numberOfLeadingZeros(0x6)); 1064 assertEquals(29, Integer.numberOfLeadingZeros(0x7)); 1065 assertEquals(28, Integer.numberOfLeadingZeros(0x8)); 1066 assertEquals(28, Integer.numberOfLeadingZeros(0x9)); 1067 assertEquals(28, Integer.numberOfLeadingZeros(0xA)); 1068 assertEquals(28, Integer.numberOfLeadingZeros(0xB)); 1069 assertEquals(28, Integer.numberOfLeadingZeros(0xC)); 1070 assertEquals(28, Integer.numberOfLeadingZeros(0xD)); 1071 assertEquals(28, Integer.numberOfLeadingZeros(0xE)); 1072 assertEquals(28, Integer.numberOfLeadingZeros(0xF)); 1073 assertEquals(27, Integer.numberOfLeadingZeros(0x10)); 1074 assertEquals(24, Integer.numberOfLeadingZeros(0x80)); 1075 assertEquals(24, Integer.numberOfLeadingZeros(0xF0)); 1076 assertEquals(23, Integer.numberOfLeadingZeros(0x100)); 1077 assertEquals(20, Integer.numberOfLeadingZeros(0x800)); 1078 assertEquals(20, Integer.numberOfLeadingZeros(0xF00)); 1079 assertEquals(19, Integer.numberOfLeadingZeros(0x1000)); 1080 assertEquals(16, Integer.numberOfLeadingZeros(0x8000)); 1081 assertEquals(16, Integer.numberOfLeadingZeros(0xF000)); 1082 assertEquals(15, Integer.numberOfLeadingZeros(0x10000)); 1083 assertEquals(12, Integer.numberOfLeadingZeros(0x80000)); 1084 assertEquals(12, Integer.numberOfLeadingZeros(0xF0000)); 1085 assertEquals(11, Integer.numberOfLeadingZeros(0x100000)); 1086 assertEquals(8, Integer.numberOfLeadingZeros(0x800000)); 1087 assertEquals(8, Integer.numberOfLeadingZeros(0xF00000)); 1088 assertEquals(7, Integer.numberOfLeadingZeros(0x1000000)); 1089 assertEquals(4, Integer.numberOfLeadingZeros(0x8000000)); 1090 assertEquals(4, Integer.numberOfLeadingZeros(0xF000000)); 1091 assertEquals(3, Integer.numberOfLeadingZeros(0x10000000)); 1092 assertEquals(0, Integer.numberOfLeadingZeros(0x80000000)); 1093 assertEquals(0, Integer.numberOfLeadingZeros(0xF0000000)); 1094 1095 assertEquals(1, Integer.numberOfLeadingZeros(Integer.MAX_VALUE)); 1096 assertEquals(0, Integer.numberOfLeadingZeros(Integer.MIN_VALUE)); 1097 } 1098 1099 /** 1100 * java.lang.Integer#numberOfTrailingZeros(int) 1101 */ 1102 public void test_numberOfTrailingZerosI() { 1103 assertEquals(32, Integer.numberOfTrailingZeros(0x0)); 1104 assertEquals(31, Integer.numberOfTrailingZeros(Integer.MIN_VALUE)); 1105 assertEquals(0, Integer.numberOfTrailingZeros(Integer.MAX_VALUE)); 1106 1107 assertEquals(0, Integer.numberOfTrailingZeros(0x1)); 1108 assertEquals(3, Integer.numberOfTrailingZeros(0x8)); 1109 assertEquals(0, Integer.numberOfTrailingZeros(0xF)); 1110 1111 assertEquals(4, Integer.numberOfTrailingZeros(0x10)); 1112 assertEquals(7, Integer.numberOfTrailingZeros(0x80)); 1113 assertEquals(4, Integer.numberOfTrailingZeros(0xF0)); 1114 1115 assertEquals(8, Integer.numberOfTrailingZeros(0x100)); 1116 assertEquals(11, Integer.numberOfTrailingZeros(0x800)); 1117 assertEquals(8, Integer.numberOfTrailingZeros(0xF00)); 1118 1119 assertEquals(12, Integer.numberOfTrailingZeros(0x1000)); 1120 assertEquals(15, Integer.numberOfTrailingZeros(0x8000)); 1121 assertEquals(12, Integer.numberOfTrailingZeros(0xF000)); 1122 1123 assertEquals(16, Integer.numberOfTrailingZeros(0x10000)); 1124 assertEquals(19, Integer.numberOfTrailingZeros(0x80000)); 1125 assertEquals(16, Integer.numberOfTrailingZeros(0xF0000)); 1126 1127 assertEquals(20, Integer.numberOfTrailingZeros(0x100000)); 1128 assertEquals(23, Integer.numberOfTrailingZeros(0x800000)); 1129 assertEquals(20, Integer.numberOfTrailingZeros(0xF00000)); 1130 1131 assertEquals(24, Integer.numberOfTrailingZeros(0x1000000)); 1132 assertEquals(27, Integer.numberOfTrailingZeros(0x8000000)); 1133 assertEquals(24, Integer.numberOfTrailingZeros(0xF000000)); 1134 1135 assertEquals(28, Integer.numberOfTrailingZeros(0x10000000)); 1136 assertEquals(31, Integer.numberOfTrailingZeros(0x80000000)); 1137 assertEquals(28, Integer.numberOfTrailingZeros(0xF0000000)); 1138 } 1139 1140 /** 1141 * java.lang.Integer#bitCount(int) 1142 */ 1143 public void test_bitCountI() { 1144 assertEquals(0, Integer.bitCount(0x0)); 1145 assertEquals(1, Integer.bitCount(0x1)); 1146 assertEquals(1, Integer.bitCount(0x2)); 1147 assertEquals(2, Integer.bitCount(0x3)); 1148 assertEquals(1, Integer.bitCount(0x4)); 1149 assertEquals(2, Integer.bitCount(0x5)); 1150 assertEquals(2, Integer.bitCount(0x6)); 1151 assertEquals(3, Integer.bitCount(0x7)); 1152 assertEquals(1, Integer.bitCount(0x8)); 1153 assertEquals(2, Integer.bitCount(0x9)); 1154 assertEquals(2, Integer.bitCount(0xA)); 1155 assertEquals(3, Integer.bitCount(0xB)); 1156 assertEquals(2, Integer.bitCount(0xC)); 1157 assertEquals(3, Integer.bitCount(0xD)); 1158 assertEquals(3, Integer.bitCount(0xE)); 1159 assertEquals(4, Integer.bitCount(0xF)); 1160 1161 assertEquals(8, Integer.bitCount(0xFF)); 1162 assertEquals(12, Integer.bitCount(0xFFF)); 1163 assertEquals(16, Integer.bitCount(0xFFFF)); 1164 assertEquals(20, Integer.bitCount(0xFFFFF)); 1165 assertEquals(24, Integer.bitCount(0xFFFFFF)); 1166 assertEquals(28, Integer.bitCount(0xFFFFFFF)); 1167 assertEquals(32, Integer.bitCount(0xFFFFFFFF)); 1168 } 1169 1170 /** 1171 * java.lang.Integer#rotateLeft(int, int) 1172 */ 1173 public void test_rotateLeftII() { 1174 assertEquals(0xF, Integer.rotateLeft(0xF, 0)); 1175 assertEquals(0xF0, Integer.rotateLeft(0xF, 4)); 1176 assertEquals(0xF00, Integer.rotateLeft(0xF, 8)); 1177 assertEquals(0xF000, Integer.rotateLeft(0xF, 12)); 1178 assertEquals(0xF0000, Integer.rotateLeft(0xF, 16)); 1179 assertEquals(0xF00000, Integer.rotateLeft(0xF, 20)); 1180 assertEquals(0xF000000, Integer.rotateLeft(0xF, 24)); 1181 assertEquals(0xF0000000, Integer.rotateLeft(0xF, 28)); 1182 assertEquals(0xF0000000, Integer.rotateLeft(0xF0000000, 32)); 1183 } 1184 1185 /** 1186 * java.lang.Integer#rotateRight(int, int) 1187 */ 1188 public void test_rotateRightII() { 1189 assertEquals(0xF, Integer.rotateRight(0xF0, 4)); 1190 assertEquals(0xF, Integer.rotateRight(0xF00, 8)); 1191 assertEquals(0xF, Integer.rotateRight(0xF000, 12)); 1192 assertEquals(0xF, Integer.rotateRight(0xF0000, 16)); 1193 assertEquals(0xF, Integer.rotateRight(0xF00000, 20)); 1194 assertEquals(0xF, Integer.rotateRight(0xF000000, 24)); 1195 assertEquals(0xF, Integer.rotateRight(0xF0000000, 28)); 1196 assertEquals(0xF0000000, Integer.rotateRight(0xF0000000, 32)); 1197 assertEquals(0xF0000000, Integer.rotateRight(0xF0000000, 0)); 1198 1199 } 1200 1201 /** 1202 * java.lang.Integer#reverseBytes(int) 1203 */ 1204 public void test_reverseBytesI() { 1205 assertEquals(0xAABBCCDD, Integer.reverseBytes(0xDDCCBBAA)); 1206 assertEquals(0x11223344, Integer.reverseBytes(0x44332211)); 1207 assertEquals(0x00112233, Integer.reverseBytes(0x33221100)); 1208 assertEquals(0x20000002, Integer.reverseBytes(0x02000020)); 1209 } 1210 1211 /** 1212 * java.lang.Integer#reverse(int) 1213 */ 1214 public void test_reverseI() { 1215 assertEquals(-1, Integer.reverse(-1)); 1216 assertEquals(0x80000000, Integer.reverse(1)); 1217 } 1218 1219 /** 1220 * java.lang.Integer#signum(int) 1221 */ 1222 public void test_signumI() { 1223 for (int i = -128; i < 0; i++) { 1224 assertEquals(-1, Integer.signum(i)); 1225 } 1226 assertEquals(0, Integer.signum(0)); 1227 for (int i = 1; i <= 127; i++) { 1228 assertEquals(1, Integer.signum(i)); 1229 } 1230 } 1231} 1232