1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * 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 17 class Main extends IntMathBase { 18 19 public static boolean mBoolean1, mBoolean2; 20 public static byte mByte1, mByte2; 21 public static char mChar1, mChar2; 22 public static short mShort1, mShort2; 23 public static int mInt1, mInt2; 24 public static float mFloat1, mFloat2; 25 public static long mLong1, mLong2; 26 public static double mDouble1, mDouble2; 27 public static volatile long mVolatileLong1, mVolatileLong2; 28 29 30 private int foo_; 31 32 public Main(int stuff) { 33 super(); 34 foo_ = stuff; 35 } 36 37 public Main() { 38 super(); 39 foo_ = 123; 40 } 41 42 /* Regression test: triggered an SSA renaming bug. */ 43 static long divideLongByBillion(long a) { 44 long quot; 45 long rem; 46 47 if (a >= 0) { 48 long bLong = 1000000000L; 49 quot = (a / bLong); 50 rem = (a % bLong); 51 } else { 52 /* 53 * Make the dividend positive shifting it right by 1 bit then get 54 * the quotient an remainder and correct them properly 55 */ 56 long aPos = a >>> 1; 57 long bPos = 1000000000L >>> 1; 58 quot = aPos / bPos; 59 rem = aPos % bPos; 60 // double the remainder and add 1 if 'a' is odd 61 rem = (rem << 1) + (a & 1); 62 } 63 return ((rem << 32) | (quot & 0xFFFFFFFFL)); 64 } 65 66 67 static int instanceTest(int x) { 68 IntMathBase a = new IntMathBase(); 69 Main b = new Main(); 70 71 if (!(null instanceof IntMathBase)) { 72 x = x + 42; 73 } 74 75 if (a instanceof IntMathBase) { 76 x = x * 2; 77 } 78 79 if (a instanceof Main) { 80 x = x + 13; 81 } 82 83 if (b instanceof IntMathBase) { 84 x = x -1; 85 } 86 87 if (b instanceof Main) { 88 x = x + 1333; 89 } 90 return x; 91 } 92 93 int tryThing() { 94 int val = super.tryThing(); 95 return val + 10; 96 } 97 98 static int superTest(int x) { 99 Main instance = new Main(); 100 Main base = instance; 101 int val1 = instance.tryThing(); 102 int val2 = base.tryThing(); 103 return val1 + val2 + x; 104 } 105 106 static int constClassTest(int x) { 107 Class<?> c = String.class; 108 if (c != null) { 109 return x * 2; 110 } else { 111 return x; 112 } 113 } 114 115 static int constStringTest(int x) { 116 String str = "Hello World!"; 117 return x + str.length(); 118 } 119 120 static void throwNullPointerException() { 121 throw new NullPointerException(); 122 } 123 124 static void throwImplicitNullPointerException() { 125 throw null; 126 } 127 128 static int catchBlock(int x) { 129 try { 130 if (x == 1000) { 131 x += 123; 132 throwNullPointerException(); 133 } else { 134 x += 321; 135 throwImplicitNullPointerException(); 136 } 137 } catch (NullPointerException npe) { 138 x += 456; 139 } 140 return x; 141 } 142 143 static int catchBlockNoThrow(int x) { 144 try { 145 x += 123; 146 } catch (NullPointerException npe) { 147 x += 456; 148 } 149 return x; 150 } 151 152 static int staticFieldTest(int x) { 153 mBoolean1 = true; 154 mBoolean2 = false; 155 mByte1 = 127; 156 mByte2 = -128; 157 mChar1 = 32767; 158 mChar2 = 65535; 159 mShort1 = 32767; 160 mShort2 = -32768; 161 mInt1 = 65537; 162 mInt2 = -65537; 163 mFloat1 = 3.1415f; 164 mFloat2 = -1.0f / 0.0f; // -inf 165 mLong1 = 1234605616436508552L; // 0x1122334455667788 166 mLong2 = -1234605616436508552L; 167 mDouble1 = 3.1415926535; 168 mDouble2 = 1.0 / 0.0; // +inf 169 mVolatileLong1 = mLong1 - 1; 170 mVolatileLong2 = mLong2 + 1; 171 172 if (!mBoolean1) { return 10; } 173 if (mBoolean2) { return 11; } 174 if (mByte1 != 127) { return 12; } 175 if (mByte2 != -128) { return 13; } 176 if (mChar1 != 32767) { return 14; } 177 if (mChar2 != 65535) { return 15; } 178 if (mShort1 != 32767) { return 16; } 179 if (mShort2 != -32768) { return 17; } 180 if (mInt1 != 65537) { return 18; } 181 if (mInt2 != -65537) { return 19; } 182 if (!(mFloat1 > 3.141f && mFloat1 < 3.142f)) { return 20; } 183 if (mFloat2 >= mFloat1) { return 21; } 184 if (mLong1 != 1234605616436508552L) { return 22; } 185 if (mLong2 != -1234605616436508552L) { return 23; } 186 if (!(mDouble1 > 3.141592653 && mDouble1 < 3.141592654)) { return 24; } 187 if (mDouble2 <= mDouble1) { return 25; } 188 if (mVolatileLong1 != 1234605616436508551L) { return 26; } 189 if (mVolatileLong2 != -1234605616436508551L) { return 27; } 190 191 return 1000 + x; 192 } 193 194 /* 195 * Try to cause some unary operations. 196 */ 197 static int unopTest(int x) { 198 x = -x; 199 x ^= 0xffffffff; 200 return x; 201 } 202 203 static int shiftTest1() { 204 final int[] mBytes = { 205 0x11, 0x22, 0x33, 0x44, 0x88, 0x99, 0xaa, 0xbb 206 }; 207 long l; 208 int i1, i2; 209 210 if (mBytes[0] != 0x11) return 20; 211 if (mBytes[1] != 0x22) return 21; 212 if (mBytes[2] != 0x33) return 22; 213 if (mBytes[3] != 0x44) return 23; 214 if (mBytes[4] != 0x88) return 24; 215 if (mBytes[5] != 0x99) return 25; 216 if (mBytes[6] != 0xaa) return 26; 217 if (mBytes[7] != 0xbb) return 27; 218 219 i1 = mBytes[0] | mBytes[1] << 8 | mBytes[2] << 16 | mBytes[3] << 24; 220 i2 = mBytes[4] | mBytes[5] << 8 | mBytes[6] << 16 | mBytes[7] << 24; 221 l = i1 | ((long)i2 << 32); 222 223 if (i1 != 0x44332211) { return 0x80000000 | i1; } 224 if (i2 != 0xbbaa9988) { return 2; } 225 if (l != 0xbbaa998844332211L) { return 3; } 226 227 l = (long)mBytes[0] 228 | (long)mBytes[1] << 8 229 | (long)mBytes[2] << 16 230 | (long)mBytes[3] << 24 231 | (long)mBytes[4] << 32 232 | (long)mBytes[5] << 40 233 | (long)mBytes[6] << 48 234 | (long)mBytes[7] << 56; 235 236 if (l != 0xbbaa998844332211L) { return 4; } 237 return 0; 238 } 239 240 static int shiftTest2() { 241 242 long a = 0x11; 243 long b = 0x22; 244 long c = 0x33; 245 long d = 0x44; 246 long e = 0x55; 247 long f = 0x66; 248 long g = 0x77; 249 long h = 0x88; 250 251 long result = ((a << 56) | (b << 48) | (c << 40) | (d << 32) | 252 (e << 24) | (f << 16) | (g << 8) | h); 253 254 if (result != 0x1122334455667788L) { return 1; } 255 return 0; 256 } 257 258 static int unsignedShiftTest() { 259 byte b = -4; 260 short s = -4; 261 char c = 0xfffc; 262 int i = -4; 263 264 b >>>= 4; 265 s >>>= 4; 266 c >>>= 4; 267 i >>>= 4; 268 269 if ((int) b != -1) { return 1; } 270 if ((int) s != -1) { return 2; } 271 if ((int) c != 0x0fff) { return 3; } 272 if (i != 268435455) { return 4; } 273 return 0; 274 } 275 276 static int convTest() { 277 278 float f; 279 double d; 280 int i; 281 long l; 282 283 /* int --> long */ 284 i = 7654; 285 l = (long) i; 286 if (l != 7654L) { return 1; } 287 288 i = -7654; 289 l = (long) i; 290 if (l != -7654L) { return 2; } 291 292 /* long --> int (with truncation) */ 293 l = 5678956789L; 294 i = (int) l; 295 if (i != 1383989493) { return 3; } 296 297 l = -5678956789L; 298 i = (int) l; 299 if (i != -1383989493) { return 4; } 300 301 /* long --> double */ 302 l = 0x7FFFFFFFL; 303 d = (double) l; 304 if (Double.doubleToRawLongBits(d) != 0x41dfffffffc00000L) { return 5; } 305 306 l = 0xFFFFFFFFL; 307 d = (double) l; 308 if (Double.doubleToRawLongBits(d) != 0x41efffffffe00000L) { return 6; } 309 310 l = 0x7FFFFFFFFFFFFFFFL; 311 d = (double) l; 312 if (Double.doubleToRawLongBits(d) != 0x43e0000000000000L) { return 7; } 313 314 l = 0xFFFFFFFFFFFFFFFFL; 315 d = (double) l; 316 if (Double.doubleToRawLongBits(d) != 0xbff0000000000000L) { return 8; } 317 318 return 0; 319 } 320 321 static int charSubTest() { 322 323 char char1 = 0x00e9; 324 char char2 = 0xffff; 325 int i; 326 327 /* chars are unsigned-expanded to ints before subtraction */ 328 i = char1 - char2; 329 if (i != 0xffff00ea) { return 1; } 330 return 0; 331 } 332 333 /* 334 * We pass in the arguments and return the results so the compiler 335 * doesn't do the math for us. (x=70000, y=-3) 336 */ 337 static int intOperTest(int x, int y) { 338 int[] results = new int[10]; 339 340 /* this seems to generate "op-int" instructions */ 341 results[0] = x + y; 342 results[1] = x - y; 343 results[2] = x * y; 344 results[3] = x * x; 345 results[4] = x / y; 346 results[5] = x % -y; 347 results[6] = x & y; 348 results[7] = x | y; 349 results[8] = x ^ y; 350 351 /* this seems to generate "op-int/2addr" instructions */ 352 results[9] = x + ((((((((x + y) - y) * y) / y) % y) & y) | y) ^ y); 353 354 /* check this edge case while we're here (div-int/2addr) */ 355 int minInt = -2147483648; 356 int negOne = -results[5]; 357 int plusOne = 1; 358 int result = (((minInt + plusOne) - plusOne) / negOne) / negOne; 359 int shouldBeZero = minInt % negOne; 360 361 if (result != minInt) { return 1;}; 362 if (results[0] != 69997) { return 2;}; 363 if (results[1] != 70003) { return 3;}; 364 if (results[2] != -210000) { return 4;}; 365 if (results[3] != 605032704) { return 5;}; 366 if (results[4] != -23333) { return 6;}; 367 if (results[5] != 1) { return 7;}; 368 if (results[6] != 70000) { return 8;}; 369 if (results[7] != -3) { return 9;}; 370 if (results[8] != -70003) { return 10;}; 371 if (results[9] != 70000) { return 11;}; 372 if (shouldBeZero != 0) { return 12;}; 373 374 return 0; 375 } 376 377 /* 378 * More operations, this time with 16-bit constants. (x=77777) 379 */ 380 static int lit16Test(int x) { 381 382 int[] results = new int[10]; 383 384 /* try to generate op-int/lit16" instructions */ 385 results[0] = x + 1000; 386 results[1] = 1000 - x; 387 results[2] = x * 1000; 388 results[3] = x / 1000; 389 results[4] = x % 1000; 390 results[5] = x & 1000; 391 results[6] = x | -1000; 392 results[7] = x ^ -1000; 393 /* use an 16-bit constant that has its MSB (bit-15) set */ 394 results[8] = x / 32769; 395 results[9] = x / -32769; 396 397 if (results[0] != 78777) { return 1; } 398 if (results[1] != -76777) { return 2; } 399 if (results[2] != 77777000) { return 3; } 400 if (results[3] != 77) { return 4; } 401 if (results[4] != 777) { return 5; } 402 if (results[5] != 960) { return 6; } 403 if (results[6] != -39) { return 7; } 404 if (results[7] != -76855) { return 8; } 405 if (results[8] != 2) { return 9; } 406 if (results[9] != -2) { return 10; } 407 return 0; 408 } 409 410 /* 411 * More operations, this time with 8-bit constants. (x=-55555) 412 */ 413 static int lit8Test(int x) { 414 415 int[] results = new int[9]; 416 417 /* try to generate op-int/lit8" instructions */ 418 results[0] = x + 10; 419 results[1] = 10 - x; 420 results[2] = x * 10; 421 results[3] = x / 10; 422 results[4] = x % 10; 423 results[5] = x & 10; 424 results[6] = x | -10; 425 results[7] = x ^ -10; 426 results[8] = x * -256; 427 int minInt = -2147483648; 428 int result = minInt / -1; 429 if (result != minInt) {return 1; } 430 if (results[0] != -55545) {return 2; } 431 if (results[1] != 55565) {return 3; } 432 if (results[2] != -555550) {return 4; } 433 if (results[3] != -5555) {return 5; } 434 if (results[4] != -5) {return 6; } 435 if (results[5] != 8) {return 7; } 436 if (results[6] != -1) {return 8; } 437 if (results[7] != 55563) {return 9; } 438 if (results[8] != 14222080) {return 10; } 439 return 0; 440 } 441 442 443 /* 444 * Shift some data. (value=0xff00aa01, dist=8) 445 */ 446 static int intShiftTest(int value, int dist) { 447 int results[] = new int[4]; 448 results[0] = value << dist; 449 results[1] = value >> dist; 450 results[2] = value >>> dist; 451 results[3] = (((value << dist) >> dist) >>> dist) << dist; 452 if (results[0] != 0x00aa0100) {return 1; } 453 if (results[1] != 0xffff00aa) {return 2; } 454 if (results[2] != 0x00ff00aa) {return 3; } 455 if (results[3] != 0xaa00) {return 4; } 456 return 0; 457 } 458 459 /* 460 * We pass in the arguments and return the results so the compiler 461 * doesn't do the math for us. (x=70000000000, y=-3) 462 */ 463 static int longOperTest(long x, long y) { 464 long[] results = new long[10]; 465 466 /* this seems to generate "op-long" instructions */ 467 results[0] = x + y; 468 results[1] = x - y; 469 results[2] = x * y; 470 results[3] = x * x; 471 results[4] = x / y; 472 results[5] = x % -y; 473 results[6] = x & y; 474 results[7] = x | y; 475 results[8] = x ^ y; 476 /* this seems to generate "op-long/2addr" instructions */ 477 results[9] = x + ((((((((x + y) - y) * y) / y) % y) & y) | y) ^ y); 478 /* check this edge case while we're here (div-long/2addr) */ 479 long minLong = -9223372036854775808L; 480 long negOne = -results[5]; 481 long plusOne = 1; 482 long result = (((minLong + plusOne) - plusOne) / negOne) / negOne; 483 if (result != minLong) { return 1; } 484 if (results[0] != 69999999997L) { return 2; } 485 if (results[1] != 70000000003L) { return 3; } 486 if (results[2] != -210000000000L) { return 4; } 487 if (results[3] != -6833923606740729856L) { return 5; } // overflow 488 if (results[4] != -23333333333L) { return 6; } 489 if (results[5] != 1) { return 7; } 490 if (results[6] != 70000000000L) { return 8; } 491 if (results[7] != -3) { return 9; } 492 if (results[8] != -70000000003L) { return 10; } 493 if (results[9] != 70000000000L) { return 11; } 494 if (results.length != 10) { return 12; } 495 return 0; 496 } 497 498 /* 499 * Shift some data. (value=0xd5aa96deff00aa01, dist=16) 500 */ 501 static long longShiftTest(long value, int dist) { 502 long results[] = new long[4]; 503 results[0] = value << dist; 504 results[1] = value >> dist; 505 results[2] = value >>> dist; 506 results[3] = (((value << dist) >> dist) >>> dist) << dist; 507 if (results[0] != 0x96deff00aa010000L) { return results[0]; } 508 if (results[1] != 0xffffd5aa96deff00L) { return results[1]; } 509 if (results[2] != 0x0000d5aa96deff00L) { return results[2]; } 510 if (results[3] != 0xffff96deff000000L) { return results[3]; } 511 if (results.length != 4) { return 5; } 512 513 return results[0]; // test return-long 514 } 515 516 static int switchTest(int a) { 517 int res = 1234; 518 519 switch (a) { 520 case -1: res = 1; return res; 521 case 0: res = 2; return res; 522 case 1: /*correct*/ break; 523 case 2: res = 3; return res; 524 case 3: res = 4; return res; 525 case 4: res = 5; return res; 526 default: res = 6; return res; 527 } 528 switch (a) { 529 case 3: res = 7; return res; 530 case 4: res = 8; return res; 531 default: /*correct*/ break; 532 } 533 534 a = 0x12345678; 535 536 switch (a) { 537 case 0x12345678: /*correct*/ break; 538 case 0x12345679: res = 9; return res; 539 default: res = 1; return res; 540 } 541 switch (a) { 542 case 57: res = 10; return res; 543 case -6: res = 11; return res; 544 case 0x12345678: /*correct*/ break; 545 case 22: res = 12; return res; 546 case 3: res = 13; return res; 547 default: res = 14; return res; 548 } 549 switch (a) { 550 case -6: res = 15; return res; 551 case 3: res = 16; return res; 552 default: /*correct*/ break; 553 } 554 555 a = -5; 556 switch (a) { 557 case 12: res = 17; return res; 558 case -5: /*correct*/ break; 559 case 0: res = 18; return res; 560 default: res = 19; return res; 561 } 562 563 switch (a) { 564 default: /*correct*/ break; 565 } 566 return res; 567 } 568 /* 569 * Test the integer comparisons in various ways. 570 */ 571 static int testIntCompare(int minus, int plus, int plus2, int zero) { 572 int res = 1111; 573 574 if (minus > plus) 575 return 1; 576 if (minus >= plus) 577 return 2; 578 if (plus < minus) 579 return 3; 580 if (plus <= minus) 581 return 4; 582 if (plus == minus) 583 return 5; 584 if (plus != plus2) 585 return 6; 586 587 /* try a branch-taken */ 588 if (plus != minus) { 589 res = res; 590 } else { 591 return 7; 592 } 593 594 if (minus > 0) 595 return 8; 596 if (minus >= 0) 597 return 9; 598 if (plus < 0) 599 return 10; 600 if (plus <= 0) 601 return 11; 602 if (plus == 0) 603 return 12; 604 if (zero != 0) 605 return 13; 606 607 if (zero == 0) { 608 res = res; 609 } else { 610 return 14; 611 } 612 return res; 613 } 614 615 /* 616 * Test cmp-long. 617 * 618 * minus=-5, alsoMinus=0xFFFFFFFF00000009, plus=4, alsoPlus=8 619 */ 620 static int testLongCompare(long minus, long alsoMinus, long plus, 621 long alsoPlus) { 622 int res = 2222; 623 624 if (minus > plus) 625 return 2; 626 if (plus < minus) 627 return 3; 628 if (plus == minus) 629 return 4; 630 631 if (plus >= plus+1) 632 return 5; 633 if (minus >= minus+1) 634 return 6; 635 636 /* try a branch-taken */ 637 if (plus != minus) { 638 res = res; 639 } else { 640 return 7; 641 } 642 643 /* compare when high words are equal but low words differ */ 644 if (plus > alsoPlus) 645 return 8; 646 if (alsoPlus < plus) 647 return 9; 648 if (alsoPlus == plus) 649 return 10; 650 651 /* high words are equal, low words have apparently different signs */ 652 if (minus < alsoMinus) // bug! 653 return 11; 654 if (alsoMinus > minus) 655 return 12; 656 if (alsoMinus == minus) 657 return 13; 658 659 return res; 660 } 661 662 /* 663 * Test cmpl-float and cmpg-float. 664 */ 665 static int testFloatCompare(float minus, float plus, float plus2, 666 float nan) { 667 if (minus > plus) 668 return 1; 669 if (plus < minus) 670 return 2; 671 if (plus == minus) 672 return 3; 673 if (plus != plus2) 674 return 4; 675 676 if (plus <= nan) 677 return 5; 678 if (plus >= nan) 679 return 6; 680 if (minus <= nan) 681 return 7; 682 if (minus >= nan) 683 return 8; 684 if (nan >= plus) 685 return 9; 686 if (nan <= plus) 687 return 10; 688 689 if (nan == nan) 690 return 11; 691 692 return 3333; 693 } 694 695 static int testDoubleCompare(double minus, double plus, double plus2, 696 double nan) { 697 698 int res = 4444; 699 700 if (minus > plus) 701 return 1; 702 if (plus < minus) 703 return 2; 704 if (plus == minus) 705 return 3; 706 if (plus != plus2) 707 return 4; 708 709 if (plus <= nan) 710 return 5; 711 if (plus >= nan) 712 return 6; 713 if (minus <= nan) 714 return 7; 715 if (minus >= nan) 716 return 8; 717 if (nan >= plus) 718 return 9; 719 if (nan <= plus) 720 return 10; 721 722 if (nan == nan) 723 return 11; 724 return res; 725 } 726 727 static int fibonacci(int n) { 728 if (n == 0) { 729 return 0; 730 } else if (n == 1) { 731 return 1; 732 } else { 733 return fibonacci(n - 1) + fibonacci(n - 2); 734 } 735 } 736 737 static int throwAndCatch() { 738 try { 739 throwNullPointerException(); 740 return 1; 741 } catch (NullPointerException npe) { 742 return 0; 743 } 744 } 745 746 static int manyArgs(int a0, long a1, int a2, long a3, int a4, long a5, 747 int a6, int a7, double a8, float a9, double a10, short a11, int a12, 748 char a13, int a14, int a15, byte a16, boolean a17, int a18, int a19, 749 long a20, long a21, int a22, int a23, int a24, int a25, int a26) 750 { 751 if (a0 != 0) return 0; 752 if (a1 != 1L) return 1; 753 if (a2 != 2) return 2; 754 if (a3 != 3L) return 3; 755 if (a4 != 4) return 4; 756 if (a5 != 5L) return 5; 757 if (a6 != 6) return 6; 758 if (a7 != 7) return 7; 759 if (a8 != 8.0) return 8; 760 if (a9 != 9.0f) return 9; 761 if (a10 != 10.0) return 10; 762 if (a11 != (short)11) return 11; 763 if (a12 != 12) return 12; 764 if (a13 != (char)13) return 13; 765 if (a14 != 14) return 14; 766 if (a15 != 15) return 15; 767 if (a16 != (byte)-16) return 16; 768 if (a17 != true) return 17; 769 if (a18 != 18) return 18; 770 if (a19 != 19) return 19; 771 if (a20 != 20L) return 20; 772 if (a21 != 21L) return 21; 773 if (a22 != 22) return 22; 774 if (a23 != 23) return 23; 775 if (a24 != 24) return 24; 776 if (a25 != 25) return 25; 777 if (a26 != 26) return 26; 778 return -1; 779 } 780 781 int virtualCall(int a) 782 { 783 return a * 2; 784 } 785 786 void setFoo(int a) 787 { 788 foo_ = a; 789 } 790 791 int getFoo() 792 { 793 return foo_; 794 } 795 796 static int staticCall(int a) 797 { 798 Main foo = new Main(); 799 return foo.virtualCall(a); 800 } 801 802 static int testIGetPut(int a) 803 { 804 Main foo = new Main(99); 805 Main foo123 = new Main(); 806 int z = foo.getFoo(); 807 z += a; 808 z += foo123.getFoo(); 809 foo.setFoo(z); 810 return foo.getFoo(); 811 } 812 813 static int throwClassCast(Object o) { 814 return ((Integer)o).intValue(); 815 } 816 817 static int testClassCast() { 818 int res = 0; 819 try { 820 res += throwClassCast(Integer.valueOf(123)); 821 } catch(ClassCastException e) { 822 res += 456; 823 } 824 try { 825 res += throwClassCast(new Short((short)321)); 826 } catch(ClassCastException e) { 827 res += 765; 828 } 829 return res; 830 } 831 832 static void throwArrayStoreException(Object[] array, Object element) { 833 array[0] = element; 834 } 835 836 static int testArrayStoreException() { 837 int res=0; 838 Object[] array = new Number[2]; 839 try { 840 throwArrayStoreException(array, null); 841 res += 1; 842 } catch(ArrayStoreException e) { 843 res += 2; 844 } 845 try { 846 throwArrayStoreException(array, Integer.valueOf(1)); 847 res += 10; 848 } catch(ArrayStoreException e) { 849 res += 20; 850 } 851 try { 852 throwArrayStoreException(array, "hello MTV-44"); 853 res += 100; 854 } catch(ArrayStoreException e) { 855 res += 200; 856 } 857 return res; 858 } 859 860 static long recursion_count_; 861 static void throwStackOverflow(long l) { 862 recursion_count_++; 863 throwStackOverflow(recursion_count_); 864 } 865 866 static long testStackOverflow() { 867 try { 868 throwStackOverflow(0); 869 if (recursion_count_ != 0) { 870 return recursion_count_; 871 } else { 872 return -1; 873 } 874 } catch(StackOverflowError soe) { 875 return 0; 876 } 877 } 878 879 static int testArrayAllocation() { 880 int res = 0; 881 try { 882 int[] x = new int[-1]; 883 res += 1; 884 } catch (NegativeArraySizeException e) { 885 res += 2; 886 } 887 try { 888 int[] x = new int [1]; 889 res += 10; 890 } catch (Throwable e) { 891 res += 20; 892 } 893 return res; 894 } 895 896 public static void main(String[] args) { 897 boolean failure = false; 898 int res; 899 long lres; 900 901 lres = divideLongByBillion(123000000000L); 902 if (lres == 123) { 903 System.out.println("divideLongByBillion PASSED"); 904 } else { 905 System.out.println("divideLongByBillion FAILED: " + lres); 906 failure = true; 907 } 908 res = unopTest(38); 909 if (res == 37) { 910 System.out.println("unopTest PASSED"); 911 } else { 912 System.out.println("unopTest FAILED: " + res); 913 failure = true; 914 } 915 res = shiftTest1(); 916 if (res == 0) { 917 System.out.println("shiftTest1 PASSED"); 918 } else { 919 System.out.println("shiftTest1 FAILED: " + res); 920 failure = true; 921 } 922 res = shiftTest2(); 923 if (res == 0) { 924 System.out.println("shiftTest2 PASSED"); 925 } else { 926 System.out.println("shiftTest2 FAILED: " + res); 927 failure = true; 928 } 929 res = unsignedShiftTest(); 930 if (res == 0) { 931 System.out.println("unsignedShiftTest PASSED"); 932 } else { 933 System.out.println("unsignedShiftTest FAILED: " + res); 934 failure = true; 935 } 936 res = convTest(); 937 if (res == 0) { 938 System.out.println("convTest PASSED"); 939 } else { 940 System.out.println("convTest FAILED: " + res); 941 failure = true; 942 } 943 res = charSubTest(); 944 if (res == 0) { 945 System.out.println("charSubTest PASSED"); 946 } else { 947 System.out.println("charSubTest FAILED: " + res); 948 failure = true; 949 } 950 res = intOperTest(70000, -3); 951 if (res == 0) { 952 System.out.println("intOperTest PASSED"); 953 } else { 954 System.out.println("intOperTest FAILED: " + res); 955 failure = true; 956 } 957 res = lit16Test(77777); 958 if (res == 0) { 959 System.out.println("lit16Test PASSED"); 960 } else { 961 System.out.println("lit16Test FAILED: " + res); 962 failure = true; 963 } 964 res = lit8Test(-55555); 965 if (res == 0) { 966 System.out.println("lit8Test PASSED"); 967 } else { 968 System.out.println("lit8Test FAILED: " + res); 969 failure = true; 970 } 971 res = intShiftTest(0xff00aa01, 8); 972 if (res == 0) { 973 System.out.println("intShiftTest PASSED"); 974 } else { 975 System.out.println("intShiftTest FAILED: " + res); 976 failure = true; 977 } 978 res = longOperTest(70000000000L, -3L); 979 if (res == 0) { 980 System.out.println("longOperTest PASSED"); 981 } else { 982 System.out.println("longOperTest FAILED: " + res); 983 failure = true; 984 } 985 lres = longShiftTest(0xd5aa96deff00aa01L, 16); 986 if (lres == 0x96deff00aa010000L) { 987 System.out.println("longShiftTest PASSED"); 988 } else { 989 System.out.println("longShiftTest FAILED: " + lres); 990 failure = true; 991 } 992 993 res = switchTest(1); 994 if (res == 1234) { 995 System.out.println("switchTest PASSED"); 996 } else { 997 System.out.println("switchTest FAILED: " + res); 998 failure = true; 999 } 1000 1001 res = testIntCompare(-5, 4, 4, 0); 1002 if (res == 1111) { 1003 System.out.println("testIntCompare PASSED"); 1004 } else { 1005 System.out.println("testIntCompare FAILED: " + res); 1006 failure = true; 1007 } 1008 1009 res = testLongCompare(-5L, -4294967287L, 4L, 8L); 1010 if (res == 2222) { 1011 System.out.println("testLongCompare PASSED"); 1012 } else { 1013 System.out.println("testLongCompare FAILED: " + res); 1014 failure = true; 1015 } 1016 1017 res = testFloatCompare(-5.0f, 4.0f, 4.0f, (1.0f/0.0f) / (1.0f/0.0f)); 1018 if (res == 3333) { 1019 System.out.println("testFloatCompare PASSED"); 1020 } else { 1021 System.out.println("testFloatCompare FAILED: " + res); 1022 failure = true; 1023 } 1024 1025 res = testDoubleCompare(-5.0, 4.0, 4.0, (1.0/0.0) / (1.0/0.0)); 1026 if (res == 4444) { 1027 System.out.println("testDoubleCompare PASSED"); 1028 } else { 1029 System.out.println("testDoubleCompare FAILED: " + res); 1030 failure = true; 1031 } 1032 1033 res = fibonacci(10); 1034 if (res == 55) { 1035 System.out.println("fibonacci PASSED"); 1036 } else { 1037 System.out.println("fibonacci FAILED: " + res); 1038 failure = true; 1039 } 1040 1041 res = throwAndCatch(); 1042 if (res == 0) { 1043 System.out.println("throwAndCatch PASSED"); 1044 } else { 1045 System.out.println("throwAndCatch FAILED: " + res); 1046 failure = true; 1047 } 1048 1049 res = testClassCast(); 1050 if (res == 888) { 1051 System.out.println("testClassCast PASSED"); 1052 } else { 1053 System.out.println("testClassCast FAILED: " + res); 1054 failure = true; 1055 } 1056 1057 res = testArrayStoreException(); 1058 if (res == 211) { 1059 System.out.println("testArrayStore PASSED"); 1060 } else { 1061 System.out.println("testArrayStore FAILED: " + res); 1062 failure = true; 1063 } 1064 1065 lres= testStackOverflow(); 1066 if (lres == 0) { 1067 System.out.println("testStackOverflow PASSED"); 1068 } else { 1069 System.out.println("testStackOverflow FAILED: " + lres); 1070 failure = true; 1071 } 1072 1073 res = testArrayAllocation(); 1074 if (res == 12) { 1075 System.out.println("testArrayAllocation PASSED"); 1076 } else { 1077 System.out.println("testArrayAllocation FAILED: " + res); 1078 failure = true; 1079 } 1080 1081 res = manyArgs(0, 1L, 2, 3L, 4, 5L, 6, 7, 8.0, 9.0f, 10.0, 1082 (short)11, 12, (char)13, 14, 15, (byte)-16, true, 18, 1083 19, 20L, 21L, 22, 23, 24, 25, 26); 1084 if (res == -1) { 1085 System.out.println("manyArgs PASSED"); 1086 } else { 1087 System.out.println("manyArgs FAILED: " + res); 1088 failure = true; 1089 } 1090 1091 res = staticCall(3); 1092 if (res == 6) { 1093 System.out.println("virtualCall PASSED"); 1094 } else { 1095 System.out.println("virtualCall FAILED: " + res); 1096 failure = true; 1097 } 1098 1099 res = testIGetPut(111); 1100 if (res == 333) { 1101 System.out.println("testGetPut PASSED"); 1102 } else { 1103 System.out.println("testGetPut FAILED: " + res); 1104 failure = true; 1105 } 1106 1107 res = staticFieldTest(404); 1108 if (res == 1404) { 1109 System.out.println("staticFieldTest PASSED"); 1110 } else { 1111 System.out.println("staticFieldTest FAILED: " + res); 1112 failure = true; 1113 } 1114 1115 res = catchBlock(1000); 1116 if (res == 1579) { 1117 System.out.println("catchBlock(1000) PASSED"); 1118 } else { 1119 System.out.println("catchBlock(1000) FAILED: " + res); 1120 failure = true; 1121 } 1122 res = catchBlock(7000); 1123 if (res == 7777) { 1124 System.out.println("catchBlock(7000) PASSED"); 1125 } else { 1126 System.out.println("catchBlock(7000) FAILED: " + res); 1127 failure = true; 1128 } 1129 res = catchBlockNoThrow(1000); 1130 if (res == 1123) { 1131 System.out.println("catchBlockNoThrow PASSED"); 1132 } else { 1133 System.out.println("catchBlockNoThrow FAILED: " + res); 1134 failure = true; 1135 } 1136 1137 res = superTest(4141); 1138 if (res == 4175) { 1139 System.out.println("superTest PASSED"); 1140 } else { 1141 System.out.println("superTest FAILED: " + res); 1142 failure = true; 1143 } 1144 1145 res = constClassTest(1111); 1146 if (res == 2222) { 1147 System.out.println("constClassTest PASSED"); 1148 } else { 1149 System.out.println("constClassTest FAILED: " + res); 1150 failure = true; 1151 } 1152 1153 res = constStringTest(10); 1154 if (res == 22) { 1155 System.out.println("constStringTest PASSED"); 1156 } else { 1157 System.out.println("constStringTest FAILED: " + res); 1158 failure = true; 1159 } 1160 1161 res = instanceTest(10); 1162 if (res == 1436) { 1163 System.out.println("instanceTest PASSED"); 1164 } else { 1165 System.out.println("instanceTest FAILED: " + res); 1166 failure = true; 1167 } 1168 1169 System.exit(failure ? 1 : 0); 1170 } 1171 } 1172 1173 class IntMathBase { 1174 IntMathBase() { 1175 } 1176 1177 int tryThing() { 1178 return 7; 1179 } 1180 } 1181
