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.luni.tests.java.lang; 18 19import dalvik.annotation.TestTargets; 20import dalvik.annotation.TestLevel; 21import dalvik.annotation.TestTargetNew; 22import dalvik.annotation.TestTargetClass; 23 24import junit.framework.TestCase; 25 26import java.util.Properties; 27 28@TestTargetClass(Integer.class) 29public class IntegerTest extends TestCase { 30 private Properties orgProps; 31 32 @Override 33 protected void setUp() { 34 orgProps = System.getProperties(); 35 } 36 37 @Override 38 protected void tearDown() { 39 System.setProperties(orgProps); 40 } 41 42 /** 43 * @tests java.lang.Integer#byteValue() 44 */ 45 @TestTargetNew( 46 level = TestLevel.COMPLETE, 47 notes = "", 48 method = "byteValue", 49 args = {} 50 ) 51 public void test_byteValue() { 52 // Test for method byte java.lang.Integer.byteValue() 53 assertEquals("Returned incorrect byte value", -1, new Integer(65535) 54 .byteValue()); 55 assertEquals("Returned incorrect byte value", 127, new Integer(127) 56 .byteValue()); 57 } 58 59 /** 60 * @tests java.lang.Integer#compareTo(java.lang.Integer) 61 */ 62 @TestTargetNew( 63 level = TestLevel.COMPLETE, 64 notes = "", 65 method = "compareTo", 66 args = {java.lang.Integer.class} 67 ) 68 public void test_compareToLjava_lang_Integer() { 69 // Test for method int java.lang.Integer.compareTo(java.lang.Integer) 70 assertTrue("-2 compared to 1 gave non-negative answer", new Integer(-2) 71 .compareTo(new Integer(1)) < 0); 72 assertEquals("-2 compared to -2 gave non-zero answer", 0, new Integer(-2) 73 .compareTo(new Integer(-2))); 74 assertTrue("3 compared to 2 gave non-positive answer", new Integer(3) 75 .compareTo(new Integer(2)) > 0); 76 77 try { 78 new Integer(0).compareTo(null); 79 fail("No NPE"); 80 } catch (NullPointerException e) { 81 } 82 } 83 84 /** 85 * @tests java.lang.Integer#decode(java.lang.String) 86 */ 87 @TestTargetNew( 88 level = TestLevel.COMPLETE, 89 notes = "", 90 method = "decode", 91 args = {java.lang.String.class} 92 ) 93 public void test_decodeLjava_lang_String2() { 94 // Test for method java.lang.Integer 95 // java.lang.Integer.decode(java.lang.String) 96 assertEquals("Failed for 132233", 97 132233, Integer.decode("132233").intValue()); 98 assertEquals("Failed for 07654321", 99 07654321, Integer.decode("07654321").intValue()); 100 assertTrue("Failed for #1234567", 101 Integer.decode("#1234567").intValue() == 0x1234567); 102 assertTrue("Failed for 0xdAd", 103 Integer.decode("0xdAd").intValue() == 0xdad); 104 assertEquals("Failed for -23", -23, Integer.decode("-23").intValue()); 105 assertEquals("Returned incorrect value for 0 decimal", 0, Integer 106 .decode("0").intValue()); 107 assertEquals("Returned incorrect value for 0 hex", 0, Integer.decode("0x0") 108 .intValue()); 109 assertTrue("Returned incorrect value for most negative value decimal", 110 Integer.decode("-2147483648").intValue() == 0x80000000); 111 assertTrue("Returned incorrect value for most negative value hex", 112 Integer.decode("-0x80000000").intValue() == 0x80000000); 113 assertTrue("Returned incorrect value for most positive value decimal", 114 Integer.decode("2147483647").intValue() == 0x7fffffff); 115 assertTrue("Returned incorrect value for most positive value hex", 116 Integer.decode("0x7fffffff").intValue() == 0x7fffffff); 117 118 boolean exception = false; 119 try { 120 Integer.decode("0a"); 121 } catch (NumberFormatException e) { 122 // correct 123 exception = true; 124 } 125 assertTrue("Failed to throw NumberFormatException for \"Oa\"", 126 exception); 127 128 exception = false; 129 try { 130 Integer.decode("2147483648"); 131 } catch (NumberFormatException e) { 132 // Correct 133 exception = true; 134 } 135 assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); 136 137 exception = false; 138 try { 139 Integer.decode("-2147483649"); 140 } catch (NumberFormatException e) { 141 // Correct 142 exception = true; 143 } 144 assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); 145 146 exception = false; 147 try { 148 Integer.decode("0x80000000"); 149 } catch (NumberFormatException e) { 150 // Correct 151 exception = true; 152 } 153 assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); 154 155 exception = false; 156 try { 157 Integer.decode("-0x80000001"); 158 } catch (NumberFormatException e) { 159 // Correct 160 exception = true; 161 } 162 assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception); 163 164 exception = false; 165 try { 166 Integer.decode("9999999999"); 167 } catch (NumberFormatException e) { 168 // Correct 169 exception = true; 170 } 171 assertTrue("Failed to throw exception for 9999999999", exception); 172 173 try { 174 Integer.decode("-"); 175 fail("Expected exception for -"); 176 } catch (NumberFormatException e) { 177 // Expected 178 } 179 180 try { 181 Integer.decode("0x"); 182 fail("Expected exception for 0x"); 183 } catch (NumberFormatException e) { 184 // Expected 185 } 186 187 try { 188 Integer.decode("#"); 189 fail("Expected exception for #"); 190 } catch (NumberFormatException e) { 191 // Expected 192 } 193 194 try { 195 Integer.decode("x123"); 196 fail("Expected exception for x123"); 197 } catch (NumberFormatException e) { 198 // Expected 199 } 200 201 try { 202 Integer.decode(null); 203 fail("Expected exception for null"); 204 } catch (NullPointerException e) { 205 // Expected 206 } 207 208 try { 209 Integer.decode(""); 210 fail("Expected exception for empty string"); 211 } catch (NumberFormatException ex) { 212 // Expected 213 } 214 215 try { 216 Integer.decode(" "); 217 fail("Expected exception for single space"); 218 } catch (NumberFormatException ex) { 219 // Expected 220 } 221 222 } 223 224 /** 225 * @tests java.lang.Integer#doubleValue() 226 */ 227 @TestTargetNew( 228 level = TestLevel.PARTIAL_COMPLETE, 229 notes = "Checks integer's boundary values.", 230 method = "doubleValue", 231 args = {} 232 ) 233 public void test_doubleValue2() { 234 // Test for method double java.lang.Integer.doubleValue() 235 assertEquals("Returned incorrect double value", 2147483647.0, new Integer(2147483647) 236 .doubleValue(), 0.0D); 237 assertEquals("Returned incorrect double value", -2147483647.0, new Integer(-2147483647) 238 .doubleValue(), 0.0D); 239 } 240 241 /** 242 * @tests java.lang.Integer#equals(java.lang.Object) 243 */ 244 @TestTargetNew( 245 level = TestLevel.COMPLETE, 246 notes = "", 247 method = "equals", 248 args = {java.lang.Object.class} 249 ) 250 public void test_equalsLjava_lang_Object2() { 251 // Test for method boolean java.lang.Integer.equals(java.lang.Object) 252 Integer i1 = new Integer(1000); 253 Integer i2 = new Integer(1000); 254 Integer i3 = new Integer(-1000); 255 assertTrue("Equality test failed", i1.equals(i2) && !(i1.equals(i3))); 256 } 257 258 /** 259 * @tests java.lang.Integer#floatValue() 260 */ 261 @TestTargetNew( 262 level = TestLevel.PARTIAL_COMPLETE, 263 notes = "", 264 method = "floatValue", 265 args = {} 266 ) 267 public void test_floatValue2() { 268 // Test for method float java.lang.Integer.floatValue() 269 assertTrue("Returned incorrect float value", new Integer(65535) 270 .floatValue() == 65535.0f); 271 assertTrue("Returned incorrect float value", new Integer(-65535) 272 .floatValue() == -65535.0f); 273 } 274 275 /** 276 * @tests java.lang.Integer#getInteger(java.lang.String) 277 */ 278 @TestTargetNew( 279 level = TestLevel.COMPLETE, 280 notes = "", 281 method = "getInteger", 282 args = {java.lang.String.class} 283 ) 284 public void test_getIntegerLjava_lang_String() { 285 // Test for method java.lang.Integer 286 // java.lang.Integer.getInteger(java.lang.String) 287 Properties tProps = new Properties(); 288 tProps.put("testInt", "99"); 289 System.setProperties(tProps); 290 assertTrue("returned incorrect Integer", Integer.getInteger("testInt") 291 .equals(new Integer(99))); 292 assertNull("returned incorrect default Integer", Integer 293 .getInteger("ff")); 294 } 295 296 /** 297 * @tests java.lang.Integer#getInteger(java.lang.String, int) 298 */ 299 @TestTargetNew( 300 level = TestLevel.COMPLETE, 301 notes = "", 302 method = "getInteger", 303 args = {java.lang.String.class, int.class} 304 ) 305 public void test_getIntegerLjava_lang_StringI() { 306 // Test for method java.lang.Integer 307 // java.lang.Integer.getInteger(java.lang.String, int) 308 Properties tProps = new Properties(); 309 tProps.put("testInt", "99"); 310 tProps.put("testIncInt", "notInt"); 311 System.setProperties(tProps); 312 assertTrue("returned incorrect Integer", Integer.getInteger("testInt", 313 4).equals(new Integer(99))); 314 assertTrue("returned incorrect default Integer", Integer.getInteger( 315 "ff", 4).equals(new Integer(4))); 316 assertTrue("returned incorrect default Integer", Integer.getInteger( 317 "testIncInt", 4).equals(new Integer(4))); 318 } 319 320 /** 321 * @tests java.lang.Integer#getInteger(java.lang.String, java.lang.Integer) 322 */ 323 @TestTargetNew( 324 level = TestLevel.COMPLETE, 325 notes = "", 326 method = "getInteger", 327 args = {java.lang.String.class, java.lang.Integer.class} 328 ) 329 public void test_getIntegerLjava_lang_StringLjava_lang_Integer() { 330 // Test for method java.lang.Integer 331 // java.lang.Integer.getInteger(java.lang.String, java.lang.Integer) 332 Properties tProps = new Properties(); 333 tProps.put("testInt", "99"); 334 tProps.put("testIncInt", "notInt"); 335 System.setProperties(tProps); 336 assertTrue("returned incorrect Integer", Integer.getInteger("testInt", 337 new Integer(4)).equals(new Integer(99))); 338 assertTrue("returned incorrect default Integer", Integer.getInteger( 339 "ff", new Integer(4)).equals(new Integer(4))); 340 assertTrue("returned incorrect default Integer", Integer.getInteger( 341 "testIncInt", new Integer(4)).equals(new Integer(4))); 342 } 343 344 /** 345 * @tests java.lang.Integer#hashCode() 346 */ 347 @TestTargetNew( 348 level = TestLevel.COMPLETE, 349 notes = "", 350 method = "hashCode", 351 args = {} 352 ) 353 public void test_hashCode2() { 354 // Test for method int java.lang.Integer.hashCode() 355 356 Integer i1 = new Integer(1000); 357 Integer i2 = new Integer(-1000); 358 assertTrue("Returned incorrect hashcode", i1.hashCode() == 1000 359 && (i2.hashCode() == -1000)); 360 } 361 362 /** 363 * @tests java.lang.Integer#intValue() 364 */ 365 @TestTargetNew( 366 level = TestLevel.PARTIAL, 367 notes = "Checks one value.", 368 method = "intValue", 369 args = {} 370 ) 371 public void test_intValue2() { 372 // Test for method int java.lang.Integer.intValue() 373 374 Integer i = new Integer(8900); 375 assertEquals("Returned incorrect int value", 8900, i.intValue()); 376 } 377 378 /** 379 * @tests java.lang.Integer#longValue() 380 */ 381 @TestTargetNew( 382 level = TestLevel.PARTIAL, 383 notes = "Checks one value.", 384 method = "longValue", 385 args = {} 386 ) 387 public void test_longValue2() { 388 // Test for method long java.lang.Integer.longValue() 389 Integer i = new Integer(8900); 390 assertEquals("Returned incorrect long value", 8900L, i.longValue()); 391 } 392 393 /** 394 * @tests java.lang.Integer#parseInt(java.lang.String) 395 */ 396 @TestTargetNew( 397 level = TestLevel.PARTIAL_COMPLETE, 398 notes = "", 399 method = "parseInt", 400 args = {java.lang.String.class} 401 ) 402 public void test_parseIntLjava_lang_String2() { 403 // Test for method int java.lang.Integer.parseInt(java.lang.String) 404 405 int i = Integer.parseInt("-8900"); 406 assertEquals("Returned incorrect int", -8900, i); 407 assertEquals("Returned incorrect value for 0", 0, Integer.parseInt("0")); 408 assertTrue("Returned incorrect value for most negative value", Integer 409 .parseInt("-2147483648") == 0x80000000); 410 assertTrue("Returned incorrect value for most positive value", Integer 411 .parseInt("2147483647") == 0x7fffffff); 412 413 boolean exception = false; 414 try { 415 Integer.parseInt("999999999999"); 416 } catch (NumberFormatException e) { 417 // Correct 418 exception = true; 419 } 420 assertTrue("Failed to throw exception for value > int", exception); 421 422 exception = false; 423 try { 424 Integer.parseInt("2147483648"); 425 } catch (NumberFormatException e) { 426 // Correct 427 exception = true; 428 } 429 assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); 430 431 exception = false; 432 try { 433 Integer.parseInt("-2147483649"); 434 } catch (NumberFormatException e) { 435 // Correct 436 exception = true; 437 } 438 assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); 439 } 440 441 /** 442 * @tests java.lang.Integer#parseInt(java.lang.String, int) 443 */ 444 @TestTargetNew( 445 level = TestLevel.COMPLETE, 446 notes = "", 447 method = "parseInt", 448 args = {java.lang.String.class, int.class} 449 ) 450 public void test_parseIntLjava_lang_StringI2() { 451 // Test for method int java.lang.Integer.parseInt(java.lang.String, int) 452 assertEquals("Parsed dec val incorrectly", 453 -8000, Integer.parseInt("-8000", 10)); 454 assertEquals("Parsed hex val incorrectly", 455 255, Integer.parseInt("FF", 16)); 456 assertEquals("Parsed oct val incorrectly", 457 16, Integer.parseInt("20", 8)); 458 assertEquals("Returned incorrect value for 0 hex", 0, Integer.parseInt("0", 459 16)); 460 assertTrue("Returned incorrect value for most negative value hex", 461 Integer.parseInt("-80000000", 16) == 0x80000000); 462 assertTrue("Returned incorrect value for most positive value hex", 463 Integer.parseInt("7fffffff", 16) == 0x7fffffff); 464 assertEquals("Returned incorrect value for 0 decimal", 0, Integer.parseInt( 465 "0", 10)); 466 assertTrue("Returned incorrect value for most negative value decimal", 467 Integer.parseInt("-2147483648", 10) == 0x80000000); 468 assertTrue("Returned incorrect value for most positive value decimal", 469 Integer.parseInt("2147483647", 10) == 0x7fffffff); 470 471 boolean exception = false; 472 try { 473 Integer.parseInt("FFFF", 10); 474 } catch (NumberFormatException e) { 475 // Correct 476 exception = true; 477 } 478 assertTrue( 479 "Failed to throw exception when passes hex string and dec parm", 480 exception); 481 482 exception = false; 483 try { 484 Integer.parseInt("2147483648", 10); 485 } catch (NumberFormatException e) { 486 // Correct 487 exception = true; 488 } 489 assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); 490 491 exception = false; 492 try { 493 Integer.parseInt("-2147483649", 10); 494 } catch (NumberFormatException e) { 495 // Correct 496 exception = true; 497 } 498 assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); 499 500 exception = false; 501 try { 502 Integer.parseInt("80000000", 16); 503 } catch (NumberFormatException e) { 504 // Correct 505 exception = true; 506 } 507 assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); 508 509 exception = false; 510 try { 511 Integer.parseInt("-80000001", 16); 512 } catch (NumberFormatException e) { 513 // Correct 514 exception = true; 515 } 516 assertTrue("Failed to throw exception for hex MIN_VALUE + 1", exception); 517 518 exception = false; 519 try { 520 Integer.parseInt("9999999999", 10); 521 } catch (NumberFormatException e) { 522 // Correct 523 exception = true; 524 } 525 assertTrue("Failed to throw exception for 9999999999", exception); 526 } 527 528 /** 529 * @tests java.lang.Integer#shortValue() 530 */ 531 @TestTargetNew( 532 level = TestLevel.PARTIAL, 533 notes = "Checks one value.", 534 method = "shortValue", 535 args = {} 536 ) 537 public void test_shortValue2() { 538 // Test for method short java.lang.Integer.shortValue() 539 Integer i = new Integer(2147450880); 540 assertEquals("Returned incorrect long value", -32768, i.shortValue()); 541 } 542 543 /** 544 * @tests java.lang.Integer#toBinaryString(int) 545 */ 546 @TestTargetNew( 547 level = TestLevel.COMPLETE, 548 notes = "", 549 method = "toBinaryString", 550 args = {int.class} 551 ) 552 public void test_toBinaryStringI() { 553 // Test for method java.lang.String 554 // java.lang.Integer.toBinaryString(int) 555 assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toBinaryString( 556 Integer.MAX_VALUE)); 557 assertEquals("Incorrect string returned", "10000000000000000000000000000000", Integer.toBinaryString( 558 Integer.MIN_VALUE)); 559 } 560 561 /** 562 * @tests java.lang.Integer#toHexString(int) 563 */ 564 @TestTargetNew( 565 level = TestLevel.COMPLETE, 566 notes = "", 567 method = "toHexString", 568 args = {int.class} 569 ) 570 public void test_toHexStringI() { 571 // Test for method java.lang.String java.lang.Integer.toHexString(int) 572 573 String[] hexvals = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", 574 "a", "b", "c", "d", "e", "f" }; 575 576 for (int i = 0; i < 16; i++) { 577 assertTrue("Incorrect string returned " + hexvals[i], Integer 578 .toHexString(i).equals(hexvals[i])); 579 } 580 581 assertTrue("Returned incorrect hex string: " 582 + Integer.toHexString(Integer.MAX_VALUE), Integer.toHexString( 583 Integer.MAX_VALUE).equals("7fffffff")); 584 assertTrue("Returned incorrect hex string: " 585 + Integer.toHexString(Integer.MIN_VALUE), Integer.toHexString( 586 Integer.MIN_VALUE).equals("80000000")); 587 } 588 589 /** 590 * @tests java.lang.Integer#toOctalString(int) 591 */ 592 @TestTargetNew( 593 level = TestLevel.COMPLETE, 594 notes = "", 595 method = "toOctalString", 596 args = {int.class} 597 ) 598 public void test_toOctalStringI() { 599 // Test for method java.lang.String java.lang.Integer.toOctalString(int) 600 // Spec states that the int arg is treated as unsigned 601 assertEquals("Returned incorrect octal string", "17777777777", Integer.toOctalString( 602 Integer.MAX_VALUE)); 603 assertEquals("Returned incorrect octal string", "20000000000", Integer.toOctalString( 604 Integer.MIN_VALUE)); 605 } 606 607 /** 608 * @tests java.lang.Integer#toString() 609 */ 610 @TestTargetNew( 611 level = TestLevel.PARTIAL, 612 notes = "Checks one value.", 613 method = "toString", 614 args = {} 615 ) 616 public void test_toString2() { 617 // Test for method java.lang.String java.lang.Integer.toString() 618 619 Integer i = new Integer(-80001); 620 621 assertEquals("Returned incorrect String", "-80001", i.toString()); 622 } 623 624 /** 625 * @tests java.lang.Integer#toString(int) 626 */ 627 @TestTargetNew( 628 level = TestLevel.COMPLETE, 629 notes = "", 630 method = "toString", 631 args = {int.class} 632 ) 633 public void test_toStringI2() { 634 // Test for method java.lang.String java.lang.Integer.toString(int) 635 636 assertEquals("Returned incorrect String", "-80765", Integer.toString(-80765) 637 ); 638 assertEquals("Returned incorrect octal string", "2147483647", Integer.toString( 639 Integer.MAX_VALUE)); 640 assertEquals("Returned incorrect octal string", "-2147483647", Integer.toString( 641 -Integer.MAX_VALUE)); 642 assertEquals("Returned incorrect octal string", "-2147483648", Integer.toString( 643 Integer.MIN_VALUE)); 644 645 // Test for HARMONY-6068 646 assertEquals("Returned incorrect octal String", "-1000", Integer.toString(-1000)); 647 assertEquals("Returned incorrect octal String", "1000", Integer.toString(1000)); 648 assertEquals("Returned incorrect octal String", "0", Integer.toString(0)); 649 assertEquals("Returned incorrect octal String", "708", Integer.toString(708)); 650 assertEquals("Returned incorrect octal String", "-100", Integer.toString(-100)); 651 assertEquals("Returned incorrect octal String", "-1000000008", Integer.toString(-1000000008)); 652 assertEquals("Returned incorrect octal String", "2000000008", Integer.toString(2000000008)); 653 } 654 655 /** 656 * @tests java.lang.Integer#toString(int, int) 657 */ 658 @TestTargetNew( 659 level = TestLevel.COMPLETE, 660 notes = "", 661 method = "toString", 662 args = {int.class, int.class} 663 ) 664 public void test_toStringII() { 665 // Test for method java.lang.String java.lang.Integer.toString(int, int) 666 assertEquals("Returned incorrect octal string", "17777777777", Integer.toString( 667 2147483647, 8)); 668 assertTrue("Returned incorrect hex string--wanted 7fffffff but got: " 669 + Integer.toString(2147483647, 16), Integer.toString( 670 2147483647, 16).equals("7fffffff")); 671 assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toString(2147483647, 2) 672 ); 673 assertEquals("Incorrect string returned", "2147483647", Integer 674 .toString(2147483647, 10)); 675 676 assertEquals("Returned incorrect octal string", "-17777777777", Integer.toString( 677 -2147483647, 8)); 678 assertTrue("Returned incorrect hex string--wanted -7fffffff but got: " 679 + Integer.toString(-2147483647, 16), Integer.toString( 680 -2147483647, 16).equals("-7fffffff")); 681 assertEquals("Incorrect string returned", 682 "-1111111111111111111111111111111", Integer 683 .toString(-2147483647, 2)); 684 assertEquals("Incorrect string returned", "-2147483647", Integer.toString(-2147483647, 685 10)); 686 687 assertEquals("Returned incorrect octal string", "-20000000000", Integer.toString( 688 -2147483648, 8)); 689 assertTrue("Returned incorrect hex string--wanted -80000000 but got: " 690 + Integer.toString(-2147483648, 16), Integer.toString( 691 -2147483648, 16).equals("-80000000")); 692 assertEquals("Incorrect string returned", 693 "-10000000000000000000000000000000", Integer 694 .toString(-2147483648, 2)); 695 assertEquals("Incorrect string returned", "-2147483648", Integer.toString(-2147483648, 696 10)); 697 } 698 699 /** 700 * @tests java.lang.Integer#valueOf(java.lang.String) 701 */ 702 @TestTargetNew( 703 level = TestLevel.PARTIAL_COMPLETE, 704 notes = "Verifies boundary values.", 705 method = "valueOf", 706 args = {java.lang.String.class} 707 ) 708 public void test_valueOfLjava_lang_String2() { 709 // Test for method java.lang.Integer 710 // java.lang.Integer.valueOf(java.lang.String) 711 assertEquals("Returned incorrect int", 8888888, Integer.valueOf("8888888") 712 .intValue()); 713 assertTrue("Returned incorrect int", Integer.valueOf("2147483647") 714 .intValue() == Integer.MAX_VALUE); 715 assertTrue("Returned incorrect int", Integer.valueOf("-2147483648") 716 .intValue() == Integer.MIN_VALUE); 717 718 boolean exception = false; 719 try { 720 Integer.valueOf("2147483648"); 721 } catch (NumberFormatException e) { 722 // Correct 723 exception = true; 724 } 725 assertTrue("Failed to throw exception with MAX_VALUE + 1", exception); 726 727 exception = false; 728 try { 729 Integer.valueOf("-2147483649"); 730 } catch (NumberFormatException e) { 731 // Correct 732 exception = true; 733 } 734 assertTrue("Failed to throw exception with MIN_VALUE - 1", exception); 735 } 736 737 /** 738 * @tests java.lang.Integer#valueOf(java.lang.String, int) 739 */ 740 @TestTargetNew( 741 level = TestLevel.PARTIAL_COMPLETE, 742 notes = "Checks boundary values.", 743 method = "valueOf", 744 args = {java.lang.String.class, int.class} 745 ) 746 public void test_valueOfLjava_lang_StringI2() { 747 // Test for method java.lang.Integer 748 // java.lang.Integer.valueOf(java.lang.String, int) 749 assertEquals("Returned incorrect int for hex string", 255, Integer.valueOf( 750 "FF", 16).intValue()); 751 assertEquals("Returned incorrect int for oct string", 16, Integer.valueOf( 752 "20", 8).intValue()); 753 assertEquals("Returned incorrect int for bin string", 4, Integer.valueOf( 754 "100", 2).intValue()); 755 756 assertEquals("Returned incorrect int for - hex string", -255, Integer.valueOf( 757 "-FF", 16).intValue()); 758 assertEquals("Returned incorrect int for - oct string", -16, Integer.valueOf( 759 "-20", 8).intValue()); 760 assertEquals("Returned incorrect int for - bin string", -4, Integer.valueOf( 761 "-100", 2).intValue()); 762 assertTrue("Returned incorrect int", Integer.valueOf("2147483647", 10) 763 .intValue() == Integer.MAX_VALUE); 764 assertTrue("Returned incorrect int", Integer.valueOf("-2147483648", 10) 765 .intValue() == Integer.MIN_VALUE); 766 assertTrue("Returned incorrect int", Integer.valueOf("7fffffff", 16) 767 .intValue() == Integer.MAX_VALUE); 768 assertTrue("Returned incorrect int", Integer.valueOf("-80000000", 16) 769 .intValue() == Integer.MIN_VALUE); 770 771 boolean exception = false; 772 try { 773 Integer.valueOf("FF", 2); 774 } catch (NumberFormatException e) { 775 // Correct 776 exception = true; 777 } 778 assertTrue( 779 "Failed to throw exception with hex string and base 2 radix", 780 exception); 781 782 exception = false; 783 try { 784 Integer.valueOf("2147483648", 10); 785 } catch (NumberFormatException e) { 786 // Correct 787 exception = true; 788 } 789 assertTrue("Failed to throw exception with MAX_VALUE + 1", exception); 790 791 exception = false; 792 try { 793 Integer.valueOf("-2147483649", 10); 794 } catch (NumberFormatException e) { 795 // Correct 796 exception = true; 797 } 798 assertTrue("Failed to throw exception with MIN_VALUE - 1", exception); 799 800 exception = false; 801 try { 802 Integer.valueOf("80000000", 16); 803 } catch (NumberFormatException e) { 804 // Correct 805 exception = true; 806 } 807 assertTrue("Failed to throw exception with hex MAX_VALUE + 1", 808 exception); 809 810 exception = false; 811 try { 812 Integer.valueOf("-80000001", 16); 813 } catch (NumberFormatException e) { 814 // Correct 815 exception = true; 816 } 817 assertTrue("Failed to throw exception with hex MIN_VALUE - 1", 818 exception); 819 } 820 821 /** 822 * @tests java.lang.Integer#valueOf(byte) 823 */ 824 @TestTargetNew( 825 level = TestLevel.COMPLETE, 826 notes = "", 827 method = "valueOf", 828 args = {int.class} 829 ) 830 public void test_valueOfI() { 831 assertEquals(new Integer(Integer.MIN_VALUE), Integer.valueOf(Integer.MIN_VALUE)); 832 assertEquals(new Integer(Integer.MAX_VALUE), Integer.valueOf(Integer.MAX_VALUE)); 833 assertEquals(new Integer(0), Integer.valueOf(0)); 834 835 short s = -128; 836 while (s < 128) { 837 assertEquals(new Integer(s), Integer.valueOf(s)); 838 assertSame(Integer.valueOf(s), Integer.valueOf(s)); 839 s++; 840 } 841 } 842 843 /** 844 * @tests java.lang.Integer#hashCode() 845 */ 846 @TestTargetNew( 847 level = TestLevel.COMPLETE, 848 notes = "", 849 method = "hashCode", 850 args = {} 851 ) 852 public void test_hashCode() { 853 assertEquals(1, new Integer(1).hashCode()); 854 assertEquals(2, new Integer(2).hashCode()); 855 assertEquals(0, new Integer(0).hashCode()); 856 assertEquals(-1, new Integer(-1).hashCode()); 857 } 858 859 /** 860 * @tests java.lang.Integer#Integer(String) 861 */ 862 @TestTargetNew( 863 level = TestLevel.COMPLETE, 864 notes = "", 865 method = "Integer", 866 args = {java.lang.String.class} 867 ) 868 public void test_ConstructorLjava_lang_String() { 869 assertEquals(new Integer(0), new Integer("0")); 870 assertEquals(new Integer(1), new Integer("1")); 871 assertEquals(new Integer(-1), new Integer("-1")); 872 873 try { 874 new Integer("0x1"); 875 fail("Expected NumberFormatException with hex string."); 876 } catch (NumberFormatException e) {} 877 878 try { 879 new Integer("9.2"); 880 fail("Expected NumberFormatException with floating point string."); 881 } catch (NumberFormatException e) {} 882 883 try { 884 new Integer(""); 885 fail("Expected NumberFormatException with empty string."); 886 } catch (NumberFormatException e) {} 887 888 try { 889 new Integer(null); 890 fail("Expected NumberFormatException with null string."); 891 } catch (NumberFormatException e) {} 892 } 893 894 /** 895 * @tests java.lang.Integer#Integer 896 */ 897 @TestTargetNew( 898 level = TestLevel.COMPLETE, 899 notes = "", 900 method = "Integer", 901 args = {int.class} 902 ) 903 public void test_ConstructorI() { 904 assertEquals(1, new Integer(1).intValue()); 905 assertEquals(2, new Integer(2).intValue()); 906 assertEquals(0, new Integer(0).intValue()); 907 assertEquals(-1, new Integer(-1).intValue()); 908 909 Integer i = new Integer(-89000); 910 assertEquals("Incorrect Integer created", -89000, i.intValue()); 911 } 912 913 /** 914 * @tests java.lang.Integer#byteValue() 915 */ 916 @TestTargetNew( 917 level = TestLevel.COMPLETE, 918 notes = "", 919 method = "byteValue", 920 args = {} 921 ) 922 public void test_booleanValue() { 923 assertEquals(1, new Integer(1).byteValue()); 924 assertEquals(2, new Integer(2).byteValue()); 925 assertEquals(0, new Integer(0).byteValue()); 926 assertEquals(-1, new Integer(-1).byteValue()); 927 } 928 929 /** 930 * @tests java.lang.Integer#equals(Object) 931 */ 932 @TestTargetNew( 933 level = TestLevel.COMPLETE, 934 notes = "", 935 method = "equals", 936 args = {java.lang.Object.class} 937 ) 938 public void test_equalsLjava_lang_Object() { 939 assertEquals(new Integer(0), Integer.valueOf(0)); 940 assertEquals(new Integer(1), Integer.valueOf(1)); 941 assertEquals(new Integer(-1), Integer.valueOf(-1)); 942 943 Integer fixture = new Integer(25); 944 assertEquals(fixture, fixture); 945 assertFalse(fixture.equals(null)); 946 assertFalse(fixture.equals("Not a Integer")); 947 } 948 949 /** 950 * @tests java.lang.Integer#toString() 951 */ 952 @TestTargetNew( 953 level = TestLevel.COMPLETE, 954 notes = "", 955 method = "toString", 956 args = {} 957 ) 958 public void test_toString() { 959 assertEquals("-1", new Integer(-1).toString()); 960 assertEquals("0", new Integer(0).toString()); 961 assertEquals("1", new Integer(1).toString()); 962 assertEquals("-1", new Integer(0xFFFFFFFF).toString()); 963 } 964 965 /** 966 * @tests java.lang.Integer#toString 967 */ 968 @TestTargetNew( 969 level = TestLevel.COMPLETE, 970 notes = "", 971 method = "toString", 972 args = {int.class} 973 ) 974 public void test_toStringI() { 975 assertEquals("-1", Integer.toString(-1)); 976 assertEquals("0", Integer.toString(0)); 977 assertEquals("1", Integer.toString(1)); 978 assertEquals("-1", Integer.toString(0xFFFFFFFF)); 979 } 980 981 /** 982 * @tests java.lang.Integer#valueOf(String) 983 */ 984 @TestTargetNew( 985 level = TestLevel.PARTIAL_COMPLETE, 986 notes = "Doesn't check boundary values.", 987 method = "valueOf", 988 args = {java.lang.String.class} 989 ) 990 public void test_valueOfLjava_lang_String() { 991 assertEquals(new Integer(0), Integer.valueOf("0")); 992 assertEquals(new Integer(1), Integer.valueOf("1")); 993 assertEquals(new Integer(-1), Integer.valueOf("-1")); 994 995 try { 996 Integer.valueOf("0x1"); 997 fail("Expected NumberFormatException with hex string."); 998 } catch (NumberFormatException e) {} 999 1000 try { 1001 Integer.valueOf("9.2"); 1002 fail("Expected NumberFormatException with floating point string."); 1003 } catch (NumberFormatException e) {} 1004 1005 try { 1006 Integer.valueOf(""); 1007 fail("Expected NumberFormatException with empty string."); 1008 } catch (NumberFormatException e) {} 1009 1010 try { 1011 Integer.valueOf(null); 1012 fail("Expected NumberFormatException with null string."); 1013 } catch (NumberFormatException e) {} 1014 } 1015 1016 /** 1017 * @tests java.lang.Integer#valueOf(String,int) 1018 */ 1019 @TestTargetNew( 1020 level = TestLevel.PARTIAL_COMPLETE, 1021 notes = "Doesn't check boundary values.", 1022 method = "valueOf", 1023 args = {java.lang.String.class, int.class} 1024 ) 1025 public void test_valueOfLjava_lang_StringI() { 1026 assertEquals(new Integer(0), Integer.valueOf("0", 10)); 1027 assertEquals(new Integer(1), Integer.valueOf("1", 10)); 1028 assertEquals(new Integer(-1), Integer.valueOf("-1", 10)); 1029 1030 //must be consistent with Character.digit() 1031 assertEquals(Character.digit('1', 2), Integer.valueOf("1", 2).byteValue()); 1032 assertEquals(Character.digit('F', 16), Integer.valueOf("F", 16).byteValue()); 1033 1034 try { 1035 Integer.valueOf("0x1", 10); 1036 fail("Expected NumberFormatException with hex string."); 1037 } catch (NumberFormatException e) {} 1038 1039 try { 1040 Integer.valueOf("9.2", 10); 1041 fail("Expected NumberFormatException with floating point string."); 1042 } catch (NumberFormatException e) {} 1043 1044 try { 1045 Integer.valueOf("", 10); 1046 fail("Expected NumberFormatException with empty string."); 1047 } catch (NumberFormatException e) {} 1048 1049 try { 1050 Integer.valueOf(null, 10); 1051 fail("Expected NumberFormatException with null string."); 1052 } catch (NumberFormatException e) {} 1053 } 1054 1055 /** 1056 * @tests java.lang.Integer#parseInt(String) 1057 */ 1058 @TestTargetNew( 1059 level = TestLevel.PARTIAL_COMPLETE, 1060 notes = "Doesn't check boundary values.", 1061 method = "parseInt", 1062 args = {java.lang.String.class} 1063 ) 1064 public void test_parseIntLjava_lang_String() { 1065 assertEquals(0, Integer.parseInt("0")); 1066 assertEquals(1, Integer.parseInt("1")); 1067 assertEquals(-1, Integer.parseInt("-1")); 1068 1069 try { 1070 Integer.parseInt("0x1"); 1071 fail("Expected NumberFormatException with hex string."); 1072 } catch (NumberFormatException e) {} 1073 1074 try { 1075 Integer.parseInt("9.2"); 1076 fail("Expected NumberFormatException with floating point string."); 1077 } catch (NumberFormatException e) {} 1078 1079 try { 1080 Integer.parseInt(""); 1081 fail("Expected NumberFormatException with empty string."); 1082 } catch (NumberFormatException e) {} 1083 1084 try { 1085 Integer.parseInt(null); 1086 fail("Expected NumberFormatException with null string."); 1087 } catch (NumberFormatException e) {} 1088 } 1089 1090 /** 1091 * @tests java.lang.Integer#parseInt(String,int) 1092 */ 1093 @TestTargetNew( 1094 level = TestLevel.COMPLETE, 1095 notes = "", 1096 method = "parseInt", 1097 args = {java.lang.String.class, int.class} 1098 ) 1099 public void test_parseIntLjava_lang_StringI() { 1100 assertEquals(0, Integer.parseInt("0", 10)); 1101 assertEquals(1, Integer.parseInt("1", 10)); 1102 assertEquals(-1, Integer.parseInt("-1", 10)); 1103 1104 //must be consistent with Character.digit() 1105 assertEquals(Character.digit('1', 2), Integer.parseInt("1", 2)); 1106 assertEquals(Character.digit('F', 16), Integer.parseInt("F", 16)); 1107 1108 try { 1109 Integer.parseInt("0x1", 10); 1110 fail("Expected NumberFormatException with hex string."); 1111 } catch (NumberFormatException e) {} 1112 1113 try { 1114 Integer.parseInt("9.2", 10); 1115 fail("Expected NumberFormatException with floating point string."); 1116 } catch (NumberFormatException e) {} 1117 1118 try { 1119 Integer.parseInt("", 10); 1120 fail("Expected NumberFormatException with empty string."); 1121 } catch (NumberFormatException e) {} 1122 1123 try { 1124 Integer.parseInt(null, 10); 1125 fail("Expected NumberFormatException with null string."); 1126 } catch (NumberFormatException e) {} 1127 } 1128 1129 /** 1130 * @tests java.lang.Integer#decode(String) 1131 */ 1132 @TestTargetNew( 1133 level = TestLevel.COMPLETE, 1134 notes = "", 1135 method = "decode", 1136 args = {java.lang.String.class} 1137 ) 1138 public void test_decodeLjava_lang_String() { 1139 assertEquals(new Integer(0), Integer.decode("0")); 1140 assertEquals(new Integer(1), Integer.decode("1")); 1141 assertEquals(new Integer(-1), Integer.decode("-1")); 1142 assertEquals(new Integer(0xF), Integer.decode("0xF")); 1143 assertEquals(new Integer(0xF), Integer.decode("#F")); 1144 assertEquals(new Integer(0xF), Integer.decode("0XF")); 1145 assertEquals(new Integer(07), Integer.decode("07")); 1146 1147 try { 1148 Integer.decode("9.2"); 1149 fail("Expected NumberFormatException with floating point string."); 1150 } catch (NumberFormatException e) {} 1151 1152 try { 1153 Integer.decode(""); 1154 fail("Expected NumberFormatException with empty string."); 1155 } catch (NumberFormatException e) {} 1156 1157 try { 1158 Integer.decode(null); 1159 //undocumented NPE, but seems consistent across JREs 1160 fail("Expected NullPointerException with null string."); 1161 } catch (NullPointerException e) {} 1162 } 1163 1164 /** 1165 * @tests java.lang.Integer#doubleValue() 1166 */ 1167 @TestTargetNew( 1168 level = TestLevel.PARTIAL_COMPLETE, 1169 notes = "Doesn't check boundaries.", 1170 method = "doubleValue", 1171 args = {} 1172 ) 1173 public void test_doubleValue() { 1174 assertEquals(-1D, new Integer(-1).doubleValue(), 0D); 1175 assertEquals(0D, new Integer(0).doubleValue(), 0D); 1176 assertEquals(1D, new Integer(1).doubleValue(), 0D); 1177 } 1178 1179 /** 1180 * @tests java.lang.Integer#floatValue() 1181 */ 1182 @TestTargetNew( 1183 level = TestLevel.PARTIAL_COMPLETE, 1184 notes = "", 1185 method = "floatValue", 1186 args = {} 1187 ) 1188 public void test_floatValue() { 1189 assertEquals(-1F, new Integer(-1).floatValue(), 0F); 1190 assertEquals(0F, new Integer(0).floatValue(), 0F); 1191 assertEquals(1F, new Integer(1).floatValue(), 0F); 1192 } 1193 1194 /** 1195 * @tests java.lang.Integer#intValue() 1196 */ 1197 @TestTargetNew( 1198 level = TestLevel.COMPLETE, 1199 notes = "", 1200 method = "intValue", 1201 args = {} 1202 ) 1203 public void test_intValue() { 1204 assertEquals(-1, new Integer(-1).intValue()); 1205 assertEquals(0, new Integer(0).intValue()); 1206 assertEquals(1, new Integer(1).intValue()); 1207 assertEquals(Integer.MAX_VALUE, new Integer(Integer.MAX_VALUE).intValue()); 1208 assertEquals(Integer.MIN_VALUE, new Integer(Integer.MIN_VALUE).intValue()); 1209 } 1210 1211 /** 1212 * @tests java.lang.Integer#longValue() 1213 */ 1214 @TestTargetNew( 1215 level = TestLevel.COMPLETE, 1216 notes = "", 1217 method = "longValue", 1218 args = {} 1219 ) 1220 public void test_longValue() { 1221 assertEquals(-1L, new Integer(-1).longValue()); 1222 assertEquals(0L, new Integer(0).longValue()); 1223 assertEquals(1L, new Integer(1).longValue()); 1224 assertEquals(Integer.MAX_VALUE, new Integer(Integer.MAX_VALUE).longValue()); 1225 assertEquals(Integer.MIN_VALUE, new Integer(Integer.MIN_VALUE).longValue()); 1226 } 1227 1228 /** 1229 * @tests java.lang.Integer#shortValue() 1230 */ 1231 @TestTargetNew( 1232 level = TestLevel.COMPLETE, 1233 notes = "", 1234 method = "shortValue", 1235 args = {} 1236 ) 1237 public void test_shortValue() { 1238 assertEquals(-1, new Integer(-1).shortValue()); 1239 assertEquals(0, new Integer(0).shortValue()); 1240 assertEquals(1, new Integer(1).shortValue()); 1241 assertEquals(-1, new Integer(Integer.MAX_VALUE).shortValue()); 1242 assertEquals(0, new Integer(Integer.MIN_VALUE).shortValue()); 1243 } 1244 /** 1245 * @tests java.lang.Integer#highestOneBit(int) 1246 */ 1247 @TestTargetNew( 1248 level = TestLevel.COMPLETE, 1249 notes = "", 1250 method = "highestOneBit", 1251 args = {int.class} 1252 ) 1253 public void test_highestOneBitI() { 1254 assertEquals(0x08, Integer.highestOneBit(0x0A)); 1255 assertEquals(0x08, Integer.highestOneBit(0x0B)); 1256 assertEquals(0x08, Integer.highestOneBit(0x0C)); 1257 assertEquals(0x08, Integer.highestOneBit(0x0F)); 1258 assertEquals(0x80, Integer.highestOneBit(0xFF)); 1259 1260 assertEquals(0x080000, Integer.highestOneBit(0x0F1234)); 1261 assertEquals(0x800000, Integer.highestOneBit(0xFF9977)); 1262 1263 assertEquals(0x80000000, Integer.highestOneBit(0xFFFFFFFF)); 1264 1265 assertEquals(0, Integer.highestOneBit(0)); 1266 assertEquals(1, Integer.highestOneBit(1)); 1267 assertEquals(0x80000000, Integer.highestOneBit(-1)); 1268 } 1269 1270 /** 1271 * @tests java.lang.Integer#lowestOneBit(int) 1272 */ 1273 @TestTargetNew( 1274 level = TestLevel.COMPLETE, 1275 notes = "", 1276 method = "lowestOneBit", 1277 args = {int.class} 1278 ) 1279 public void test_lowestOneBitI() { 1280 assertEquals(0x10, Integer.lowestOneBit(0xF0)); 1281 1282 assertEquals(0x10, Integer.lowestOneBit(0x90)); 1283 assertEquals(0x10, Integer.lowestOneBit(0xD0)); 1284 1285 assertEquals(0x10, Integer.lowestOneBit(0x123490)); 1286 assertEquals(0x10, Integer.lowestOneBit(0x1234D0)); 1287 1288 assertEquals(0x100000, Integer.lowestOneBit(0x900000)); 1289 assertEquals(0x100000, Integer.lowestOneBit(0xD00000)); 1290 1291 assertEquals(0x40, Integer.lowestOneBit(0x40)); 1292 assertEquals(0x40, Integer.lowestOneBit(0xC0)); 1293 1294 assertEquals(0x4000, Integer.lowestOneBit(0x4000)); 1295 assertEquals(0x4000, Integer.lowestOneBit(0xC000)); 1296 1297 assertEquals(0x4000, Integer.lowestOneBit(0x99994000)); 1298 assertEquals(0x4000, Integer.lowestOneBit(0x9999C000)); 1299 1300 assertEquals(0, Integer.lowestOneBit(0)); 1301 assertEquals(1, Integer.lowestOneBit(1)); 1302 assertEquals(1, Integer.lowestOneBit(-1)); 1303 } 1304 /** 1305 * @tests java.lang.Integer#numberOfLeadingZeros(int) 1306 */ 1307 @TestTargetNew( 1308 level = TestLevel.COMPLETE, 1309 notes = "", 1310 method = "numberOfLeadingZeros", 1311 args = {int.class} 1312 ) 1313 public void test_numberOfLeadingZerosI() { 1314 assertEquals(32, Integer.numberOfLeadingZeros(0x0)); 1315 assertEquals(31, Integer.numberOfLeadingZeros(0x1)); 1316 assertEquals(30, Integer.numberOfLeadingZeros(0x2)); 1317 assertEquals(30, Integer.numberOfLeadingZeros(0x3)); 1318 assertEquals(29, Integer.numberOfLeadingZeros(0x4)); 1319 assertEquals(29, Integer.numberOfLeadingZeros(0x5)); 1320 assertEquals(29, Integer.numberOfLeadingZeros(0x6)); 1321 assertEquals(29, Integer.numberOfLeadingZeros(0x7)); 1322 assertEquals(28, Integer.numberOfLeadingZeros(0x8)); 1323 assertEquals(28, Integer.numberOfLeadingZeros(0x9)); 1324 assertEquals(28, Integer.numberOfLeadingZeros(0xA)); 1325 assertEquals(28, Integer.numberOfLeadingZeros(0xB)); 1326 assertEquals(28, Integer.numberOfLeadingZeros(0xC)); 1327 assertEquals(28, Integer.numberOfLeadingZeros(0xD)); 1328 assertEquals(28, Integer.numberOfLeadingZeros(0xE)); 1329 assertEquals(28, Integer.numberOfLeadingZeros(0xF)); 1330 assertEquals(27, Integer.numberOfLeadingZeros(0x10)); 1331 assertEquals(24, Integer.numberOfLeadingZeros(0x80)); 1332 assertEquals(24, Integer.numberOfLeadingZeros(0xF0)); 1333 assertEquals(23, Integer.numberOfLeadingZeros(0x100)); 1334 assertEquals(20, Integer.numberOfLeadingZeros(0x800)); 1335 assertEquals(20, Integer.numberOfLeadingZeros(0xF00)); 1336 assertEquals(19, Integer.numberOfLeadingZeros(0x1000)); 1337 assertEquals(16, Integer.numberOfLeadingZeros(0x8000)); 1338 assertEquals(16, Integer.numberOfLeadingZeros(0xF000)); 1339 assertEquals(15, Integer.numberOfLeadingZeros(0x10000)); 1340 assertEquals(12, Integer.numberOfLeadingZeros(0x80000)); 1341 assertEquals(12, Integer.numberOfLeadingZeros(0xF0000)); 1342 assertEquals(11, Integer.numberOfLeadingZeros(0x100000)); 1343 assertEquals(8, Integer.numberOfLeadingZeros(0x800000)); 1344 assertEquals(8, Integer.numberOfLeadingZeros(0xF00000)); 1345 assertEquals(7, Integer.numberOfLeadingZeros(0x1000000)); 1346 assertEquals(4, Integer.numberOfLeadingZeros(0x8000000)); 1347 assertEquals(4, Integer.numberOfLeadingZeros(0xF000000)); 1348 assertEquals(3, Integer.numberOfLeadingZeros(0x10000000)); 1349 assertEquals(0, Integer.numberOfLeadingZeros(0x80000000)); 1350 assertEquals(0, Integer.numberOfLeadingZeros(0xF0000000)); 1351 1352 assertEquals(1, Integer.numberOfLeadingZeros(Integer.MAX_VALUE)); 1353 assertEquals(0, Integer.numberOfLeadingZeros(Integer.MIN_VALUE)); 1354 } 1355 1356 /** 1357 * @tests 1358 * java.lang.Integer#numberOfTrailingZeros(int) 1359 */ 1360 @TestTargetNew( 1361 level = TestLevel.COMPLETE, 1362 notes = "", 1363 method = "numberOfTrailingZeros", 1364 args = {int.class} 1365 ) 1366 public void test_numberOfTrailingZerosI() { 1367 assertEquals(32, Integer.numberOfTrailingZeros(0x0)); 1368 assertEquals(31, Integer.numberOfTrailingZeros(Integer.MIN_VALUE)); 1369 assertEquals(0, Integer.numberOfTrailingZeros(Integer.MAX_VALUE)); 1370 1371 assertEquals(0, Integer.numberOfTrailingZeros(0x1)); 1372 assertEquals(3, Integer.numberOfTrailingZeros(0x8)); 1373 assertEquals(0, Integer.numberOfTrailingZeros(0xF)); 1374 1375 assertEquals(4, Integer.numberOfTrailingZeros(0x10)); 1376 assertEquals(7, Integer.numberOfTrailingZeros(0x80)); 1377 assertEquals(4, Integer.numberOfTrailingZeros(0xF0)); 1378 1379 assertEquals(8, Integer.numberOfTrailingZeros(0x100)); 1380 assertEquals(11, Integer.numberOfTrailingZeros(0x800)); 1381 assertEquals(8, Integer.numberOfTrailingZeros(0xF00)); 1382 1383 assertEquals(12, Integer.numberOfTrailingZeros(0x1000)); 1384 assertEquals(15, Integer.numberOfTrailingZeros(0x8000)); 1385 assertEquals(12, Integer.numberOfTrailingZeros(0xF000)); 1386 1387 assertEquals(16, Integer.numberOfTrailingZeros(0x10000)); 1388 assertEquals(19, Integer.numberOfTrailingZeros(0x80000)); 1389 assertEquals(16, Integer.numberOfTrailingZeros(0xF0000)); 1390 1391 assertEquals(20, Integer.numberOfTrailingZeros(0x100000)); 1392 assertEquals(23, Integer.numberOfTrailingZeros(0x800000)); 1393 assertEquals(20, Integer.numberOfTrailingZeros(0xF00000)); 1394 1395 assertEquals(24, Integer.numberOfTrailingZeros(0x1000000)); 1396 assertEquals(27, Integer.numberOfTrailingZeros(0x8000000)); 1397 assertEquals(24, Integer.numberOfTrailingZeros(0xF000000)); 1398 1399 assertEquals(28, Integer.numberOfTrailingZeros(0x10000000)); 1400 assertEquals(31, Integer.numberOfTrailingZeros(0x80000000)); 1401 assertEquals(28, Integer.numberOfTrailingZeros(0xF0000000)); 1402 } 1403 1404 /** 1405 * @tests java.lang.Integer#bitCount(int) 1406 */ 1407 @TestTargetNew( 1408 level = TestLevel.COMPLETE, 1409 notes = "", 1410 method = "bitCount", 1411 args = {int.class} 1412 ) 1413 public void test_bitCountI() { 1414 assertEquals(0, Integer.bitCount(0x0)); 1415 assertEquals(1, Integer.bitCount(0x1)); 1416 assertEquals(1, Integer.bitCount(0x2)); 1417 assertEquals(2, Integer.bitCount(0x3)); 1418 assertEquals(1, Integer.bitCount(0x4)); 1419 assertEquals(2, Integer.bitCount(0x5)); 1420 assertEquals(2, Integer.bitCount(0x6)); 1421 assertEquals(3, Integer.bitCount(0x7)); 1422 assertEquals(1, Integer.bitCount(0x8)); 1423 assertEquals(2, Integer.bitCount(0x9)); 1424 assertEquals(2, Integer.bitCount(0xA)); 1425 assertEquals(3, Integer.bitCount(0xB)); 1426 assertEquals(2, Integer.bitCount(0xC)); 1427 assertEquals(3, Integer.bitCount(0xD)); 1428 assertEquals(3, Integer.bitCount(0xE)); 1429 assertEquals(4, Integer.bitCount(0xF)); 1430 1431 assertEquals(8, Integer.bitCount(0xFF)); 1432 assertEquals(12, Integer.bitCount(0xFFF)); 1433 assertEquals(16, Integer.bitCount(0xFFFF)); 1434 assertEquals(20, Integer.bitCount(0xFFFFF)); 1435 assertEquals(24, Integer.bitCount(0xFFFFFF)); 1436 assertEquals(28, Integer.bitCount(0xFFFFFFF)); 1437 assertEquals(32, Integer.bitCount(0xFFFFFFFF)); 1438 } 1439 1440 /** 1441 * @tests java.lang.Integer#rotateLeft(int,int) 1442 */ 1443 @TestTargetNew( 1444 level = TestLevel.COMPLETE, 1445 notes = "", 1446 method = "rotateLeft", 1447 args = {int.class, int.class} 1448 ) 1449 public void test_rotateLeftII() { 1450 assertEquals(0xF, Integer.rotateLeft(0xF, 0)); 1451 assertEquals(0xF0, Integer.rotateLeft(0xF, 4)); 1452 assertEquals(0xF00, Integer.rotateLeft(0xF, 8)); 1453 assertEquals(0xF000, Integer.rotateLeft(0xF, 12)); 1454 assertEquals(0xF0000, Integer.rotateLeft(0xF, 16)); 1455 assertEquals(0xF00000, Integer.rotateLeft(0xF, 20)); 1456 assertEquals(0xF000000, Integer.rotateLeft(0xF, 24)); 1457 assertEquals(0xF0000000, Integer.rotateLeft(0xF, 28)); 1458 assertEquals(0xF0000000, Integer.rotateLeft(0xF0000000, 32)); 1459 } 1460 1461 /** 1462 * @tests java.lang.Integer#rotateRight(int,int) 1463 */ 1464 @TestTargetNew( 1465 level = TestLevel.COMPLETE, 1466 notes = "", 1467 method = "rotateRight", 1468 args = {int.class, int.class} 1469 ) 1470 public void test_rotateRightII() { 1471 assertEquals(0xF, Integer.rotateRight(0xF0, 4)); 1472 assertEquals(0xF, Integer.rotateRight(0xF00, 8)); 1473 assertEquals(0xF, Integer.rotateRight(0xF000, 12)); 1474 assertEquals(0xF, Integer.rotateRight(0xF0000, 16)); 1475 assertEquals(0xF, Integer.rotateRight(0xF00000, 20)); 1476 assertEquals(0xF, Integer.rotateRight(0xF000000, 24)); 1477 assertEquals(0xF, Integer.rotateRight(0xF0000000, 28)); 1478 assertEquals(0xF0000000, Integer.rotateRight(0xF0000000, 32)); 1479 assertEquals(0xF0000000, Integer.rotateRight(0xF0000000, 0)); 1480 1481 } 1482 1483 /** 1484 * @tests java.lang.Integer#reverseBytes(int) 1485 */ 1486 @TestTargetNew( 1487 level = TestLevel.COMPLETE, 1488 notes = "", 1489 method = "reverseBytes", 1490 args = {int.class} 1491 ) 1492 public void test_reverseBytesI() { 1493 assertEquals(0xAABBCCDD, Integer.reverseBytes(0xDDCCBBAA)); 1494 assertEquals(0x11223344, Integer.reverseBytes(0x44332211)); 1495 assertEquals(0x00112233, Integer.reverseBytes(0x33221100)); 1496 assertEquals(0x20000002, Integer.reverseBytes(0x02000020)); 1497 } 1498 1499 /** 1500 * @tests java.lang.Integer#reverse(int) 1501 */ 1502 @TestTargetNew( 1503 level = TestLevel.COMPLETE, 1504 notes = "", 1505 method = "reverse", 1506 args = {int.class} 1507 ) 1508 public void test_reverseI() { 1509 assertEquals(-1, Integer.reverse(-1)); 1510 assertEquals(0x80000000,Integer.reverse(1)); 1511 } 1512 1513 /** 1514 * @tests java.lang.Integer#signum(int) 1515 */ 1516 @TestTargetNew( 1517 level = TestLevel.COMPLETE, 1518 notes = "", 1519 method = "signum", 1520 args = {int.class} 1521 ) 1522 public void test_signumI() { 1523 for (int i = -128; i<0; i++) { 1524 assertEquals(-1, Integer.signum(i)); 1525 } 1526 assertEquals(0, Integer.signum(0)); 1527 for (int i = 1; i<=127; i++) { 1528 assertEquals(1, Integer.signum(i)); 1529 } 1530 } 1531} 1532