Mercurial > hg > graal-jvmci-8
comparison c1x4hotspotsrc/HotSpotTest/src/jttTests.java @ 1423:760213a60e8b
* rewrite of the code installation
* partial support for safepoints
* macro-based CiTargetMethod interface
* code stub support
author | Lukas Stadler <lukas.stadler@oracle.com> |
---|---|
date | Mon, 16 Aug 2010 18:59:36 -0700 |
parents | |
children | 98fffb304868 |
comparison
equal
deleted
inserted
replaced
1422:3483ec571caf | 1423:760213a60e8b |
---|---|
1 | |
2 import com.sun.hotspot.c1x.logging.Logger; | |
3 | |
4 public class jttTests { | |
5 | |
6 public static void main(String[] args) { | |
7 runTests(128, 128); | |
8 Logger.info("total: " + executed + " tests executed, " + passed + " passed, " + failed + " failed"); | |
9 } | |
10 | |
11 private static int testNumber; | |
12 private static String testName; | |
13 | |
14 private static int executed = 0; | |
15 private static int passed = 0; | |
16 private static int failed = 0; | |
17 | |
18 | |
19 public static boolean runTests(int start, int end) { | |
20 while (start <= end) { | |
21 testNumber = start; | |
22 if (!runTest(start)) { | |
23 return false; | |
24 } | |
25 start++; | |
26 } | |
27 return true; | |
28 } | |
29 | |
30 static void begin(String testName) { | |
31 jttTests.testName = testName; | |
32 executed++; | |
33 } | |
34 | |
35 static void pass() { | |
36 Logger.info("# " + testNumber + ": " + testName + " passed"); | |
37 passed++; | |
38 } | |
39 | |
40 static void fail(String runString) { | |
41 Logger.info("# " + testNumber + ": " + testName + " failed for " +runString); | |
42 failed++; | |
43 } | |
44 | |
45 static void fail(String runString, Throwable thrown) { | |
46 Logger.info("# " + testNumber + ": " + testName + " failed for " +runString +", exception " + thrown); | |
47 failed++; | |
48 } | |
49 | |
50 // Checkstyle: stop | |
51 // GENERATED TEST RUNS | |
52 public static boolean runTest(int num) { | |
53 switch (num) { | |
54 case 0: | |
55 jtt_bytecode_BC_aaload(); | |
56 break; | |
57 case 1: | |
58 jtt_bytecode_BC_aaload_1(); | |
59 break; | |
60 case 2: | |
61 jtt_bytecode_BC_aastore(); | |
62 break; | |
63 case 3: | |
64 jtt_bytecode_BC_aload_0(); | |
65 break; | |
66 case 4: | |
67 jtt_bytecode_BC_aload_1(); | |
68 break; | |
69 case 5: | |
70 jtt_bytecode_BC_aload_2(); | |
71 break; | |
72 case 6: | |
73 jtt_bytecode_BC_aload_3(); | |
74 break; | |
75 case 7: | |
76 jtt_bytecode_BC_anewarray(); | |
77 break; | |
78 case 8: | |
79 jtt_bytecode_BC_areturn(); | |
80 break; | |
81 case 9: | |
82 jtt_bytecode_BC_arraylength(); | |
83 break; | |
84 case 10: | |
85 //jtt_bytecode_BC_athrow(); | |
86 break; | |
87 case 11: | |
88 jtt_bytecode_BC_baload(); | |
89 break; | |
90 case 12: | |
91 jtt_bytecode_BC_bastore(); | |
92 break; | |
93 case 13: | |
94 jtt_bytecode_BC_caload(); | |
95 break; | |
96 case 14: | |
97 jtt_bytecode_BC_castore(); | |
98 break; | |
99 case 15: | |
100 //jtt_bytecode_BC_checkcast01(); | |
101 break; | |
102 case 16: | |
103 //jtt_bytecode_BC_checkcast02(); | |
104 break; | |
105 case 17: | |
106 jtt_bytecode_BC_d2f(); | |
107 break; | |
108 case 18: | |
109 //jtt_bytecode_BC_d2i01(); | |
110 break; | |
111 case 19: | |
112 //jtt_bytecode_BC_d2i02(); | |
113 break; | |
114 case 20: | |
115 //jtt_bytecode_BC_d2l01(); | |
116 break; | |
117 case 21: | |
118 //jtt_bytecode_BC_d2l02(); | |
119 break; | |
120 case 22: | |
121 jtt_bytecode_BC_dadd(); | |
122 break; | |
123 case 23: | |
124 jtt_bytecode_BC_daload(); | |
125 break; | |
126 case 24: | |
127 jtt_bytecode_BC_dastore(); | |
128 break; | |
129 case 25: | |
130 jtt_bytecode_BC_dcmp01(); | |
131 break; | |
132 case 26: | |
133 jtt_bytecode_BC_dcmp02(); | |
134 break; | |
135 case 27: | |
136 jtt_bytecode_BC_dcmp03(); | |
137 break; | |
138 case 28: | |
139 jtt_bytecode_BC_dcmp04(); | |
140 break; | |
141 case 29: | |
142 jtt_bytecode_BC_dcmp05(); | |
143 break; | |
144 case 30: | |
145 jtt_bytecode_BC_dcmp06(); | |
146 break; | |
147 case 31: | |
148 jtt_bytecode_BC_dcmp07(); | |
149 break; | |
150 case 32: | |
151 jtt_bytecode_BC_dcmp08(); | |
152 break; | |
153 case 33: | |
154 jtt_bytecode_BC_dcmp09(); | |
155 break; | |
156 case 34: | |
157 jtt_bytecode_BC_dcmp10(); | |
158 break; | |
159 case 35: | |
160 jtt_bytecode_BC_ddiv(); | |
161 break; | |
162 case 36: | |
163 jtt_bytecode_BC_dmul(); | |
164 break; | |
165 case 37: | |
166 jtt_bytecode_BC_dneg(); | |
167 break; | |
168 case 38: | |
169 //jtt_bytecode_BC_drem(); | |
170 break; | |
171 case 39: | |
172 jtt_bytecode_BC_dreturn(); | |
173 break; | |
174 case 40: | |
175 jtt_bytecode_BC_dsub(); | |
176 break; | |
177 case 41: | |
178 jtt_bytecode_BC_f2d(); | |
179 break; | |
180 case 42: | |
181 jtt_bytecode_BC_f2i01(); | |
182 break; | |
183 case 43: | |
184 jtt_bytecode_BC_f2i02(); | |
185 break; | |
186 case 44: | |
187 jtt_bytecode_BC_f2l01(); | |
188 break; | |
189 case 45: | |
190 jtt_bytecode_BC_f2l02(); | |
191 break; | |
192 case 46: | |
193 jtt_bytecode_BC_fadd(); | |
194 break; | |
195 case 47: | |
196 jtt_bytecode_BC_faload(); | |
197 break; | |
198 case 48: | |
199 jtt_bytecode_BC_fastore(); | |
200 break; | |
201 case 49: | |
202 jtt_bytecode_BC_fcmp01(); | |
203 break; | |
204 case 50: | |
205 jtt_bytecode_BC_fcmp02(); | |
206 break; | |
207 case 51: | |
208 jtt_bytecode_BC_fcmp03(); | |
209 break; | |
210 case 52: | |
211 jtt_bytecode_BC_fcmp04(); | |
212 break; | |
213 case 53: | |
214 jtt_bytecode_BC_fcmp05(); | |
215 break; | |
216 case 54: | |
217 jtt_bytecode_BC_fcmp06(); | |
218 break; | |
219 case 55: | |
220 jtt_bytecode_BC_fcmp07(); | |
221 break; | |
222 case 56: | |
223 jtt_bytecode_BC_fcmp08(); | |
224 break; | |
225 case 57: | |
226 jtt_bytecode_BC_fcmp09(); | |
227 break; | |
228 case 58: | |
229 jtt_bytecode_BC_fcmp10(); | |
230 break; | |
231 case 59: | |
232 jtt_bytecode_BC_fdiv(); | |
233 break; | |
234 case 60: | |
235 jtt_bytecode_BC_fload(); | |
236 break; | |
237 case 61: | |
238 jtt_bytecode_BC_fload_2(); | |
239 break; | |
240 case 62: | |
241 jtt_bytecode_BC_fmul(); | |
242 break; | |
243 case 63: | |
244 jtt_bytecode_BC_fneg(); | |
245 break; | |
246 case 64: | |
247 //jtt_bytecode_BC_frem(); | |
248 break; | |
249 case 65: | |
250 jtt_bytecode_BC_freturn(); | |
251 break; | |
252 case 66: | |
253 jtt_bytecode_BC_fsub(); | |
254 break; | |
255 case 67: | |
256 jtt_bytecode_BC_getfield(); | |
257 break; | |
258 case 68: | |
259 jtt_bytecode_BC_getstatic_b(); | |
260 break; | |
261 case 69: | |
262 jtt_bytecode_BC_getstatic_c(); | |
263 break; | |
264 case 70: | |
265 jtt_bytecode_BC_getstatic_d(); | |
266 break; | |
267 case 71: | |
268 jtt_bytecode_BC_getstatic_f(); | |
269 break; | |
270 case 72: | |
271 jtt_bytecode_BC_getstatic_i(); | |
272 break; | |
273 case 73: | |
274 jtt_bytecode_BC_getstatic_l(); | |
275 break; | |
276 case 74: | |
277 jtt_bytecode_BC_getstatic_s(); | |
278 break; | |
279 case 75: | |
280 jtt_bytecode_BC_getstatic_z(); | |
281 break; | |
282 case 76: | |
283 jtt_bytecode_BC_i2b(); | |
284 break; | |
285 case 77: | |
286 jtt_bytecode_BC_i2c(); | |
287 break; | |
288 case 78: | |
289 jtt_bytecode_BC_i2d(); | |
290 break; | |
291 case 79: | |
292 jtt_bytecode_BC_i2f(); | |
293 break; | |
294 case 80: | |
295 jtt_bytecode_BC_i2l(); | |
296 break; | |
297 case 81: | |
298 jtt_bytecode_BC_i2s(); | |
299 break; | |
300 case 82: | |
301 jtt_bytecode_BC_iadd(); | |
302 break; | |
303 case 83: | |
304 jtt_bytecode_BC_iadd2(); | |
305 break; | |
306 case 84: | |
307 jtt_bytecode_BC_iadd3(); | |
308 break; | |
309 case 85: | |
310 jtt_bytecode_BC_iaload(); | |
311 break; | |
312 case 86: | |
313 jtt_bytecode_BC_iand(); | |
314 break; | |
315 case 87: | |
316 jtt_bytecode_BC_iastore(); | |
317 break; | |
318 case 88: | |
319 jtt_bytecode_BC_iconst(); | |
320 break; | |
321 case 89: | |
322 jtt_bytecode_BC_idiv(); | |
323 break; | |
324 case 90: | |
325 jtt_bytecode_BC_idiv2(); | |
326 break; | |
327 case 91: | |
328 jtt_bytecode_BC_ifeq(); | |
329 break; | |
330 case 92: | |
331 jtt_bytecode_BC_ifeq_2(); | |
332 break; | |
333 case 93: | |
334 jtt_bytecode_BC_ifeq_3(); | |
335 break; | |
336 case 94: | |
337 jtt_bytecode_BC_ifge(); | |
338 break; | |
339 case 95: | |
340 jtt_bytecode_BC_ifge_2(); | |
341 break; | |
342 case 96: | |
343 jtt_bytecode_BC_ifge_3(); | |
344 break; | |
345 case 97: | |
346 jtt_bytecode_BC_ifgt(); | |
347 break; | |
348 case 98: | |
349 jtt_bytecode_BC_ificmplt1(); | |
350 break; | |
351 case 99: | |
352 jtt_bytecode_BC_ificmplt2(); | |
353 break; | |
354 case 100: | |
355 jtt_bytecode_BC_ificmpne1(); | |
356 break; | |
357 case 101: | |
358 jtt_bytecode_BC_ificmpne2(); | |
359 break; | |
360 case 102: | |
361 jtt_bytecode_BC_ifle(); | |
362 break; | |
363 case 103: | |
364 jtt_bytecode_BC_iflt(); | |
365 break; | |
366 case 104: | |
367 jtt_bytecode_BC_ifne(); | |
368 break; | |
369 case 105: | |
370 jtt_bytecode_BC_ifnonnull(); | |
371 break; | |
372 case 106: | |
373 jtt_bytecode_BC_ifnonnull_2(); | |
374 break; | |
375 case 107: | |
376 jtt_bytecode_BC_ifnonnull_3(); | |
377 break; | |
378 case 108: | |
379 jtt_bytecode_BC_ifnull(); | |
380 break; | |
381 case 109: | |
382 jtt_bytecode_BC_ifnull_2(); | |
383 break; | |
384 case 110: | |
385 jtt_bytecode_BC_ifnull_3(); | |
386 break; | |
387 case 111: | |
388 jtt_bytecode_BC_iinc_1(); | |
389 break; | |
390 case 112: | |
391 jtt_bytecode_BC_iinc_2(); | |
392 break; | |
393 case 113: | |
394 jtt_bytecode_BC_iinc_3(); | |
395 break; | |
396 case 114: | |
397 jtt_bytecode_BC_iinc_4(); | |
398 break; | |
399 case 115: | |
400 jtt_bytecode_BC_iload_0(); | |
401 break; | |
402 case 116: | |
403 jtt_bytecode_BC_iload_0_1(); | |
404 break; | |
405 case 117: | |
406 jtt_bytecode_BC_iload_0_2(); | |
407 break; | |
408 case 118: | |
409 jtt_bytecode_BC_iload_1(); | |
410 break; | |
411 case 119: | |
412 jtt_bytecode_BC_iload_1_1(); | |
413 break; | |
414 case 120: | |
415 jtt_bytecode_BC_iload_2(); | |
416 break; | |
417 case 121: | |
418 jtt_bytecode_BC_iload_3(); | |
419 break; | |
420 case 122: | |
421 jtt_bytecode_BC_imul(); | |
422 break; | |
423 case 123: | |
424 jtt_bytecode_BC_ineg(); | |
425 break; | |
426 case 124: | |
427 jtt_bytecode_BC_instanceof(); | |
428 break; | |
429 case 125: | |
430 jtt_bytecode_BC_invokeinterface(); | |
431 break; | |
432 case 126: | |
433 jtt_bytecode_BC_invokespecial(); | |
434 break; | |
435 case 127: | |
436 jtt_bytecode_BC_invokespecial2(); | |
437 break; | |
438 case 128: | |
439 jtt_bytecode_BC_invokestatic(); | |
440 break; | |
441 case 129: | |
442 jtt_bytecode_BC_invokevirtual(); | |
443 break; | |
444 case 130: | |
445 jtt_bytecode_BC_ior(); | |
446 break; | |
447 case 131: | |
448 jtt_bytecode_BC_irem(); | |
449 break; | |
450 case 132: | |
451 jtt_bytecode_BC_irem2(); | |
452 break; | |
453 case 133: | |
454 jtt_bytecode_BC_ireturn(); | |
455 break; | |
456 case 134: | |
457 jtt_bytecode_BC_ishl(); | |
458 break; | |
459 case 135: | |
460 jtt_bytecode_BC_ishr(); | |
461 break; | |
462 case 136: | |
463 jtt_bytecode_BC_isub(); | |
464 break; | |
465 case 137: | |
466 jtt_bytecode_BC_iushr(); | |
467 break; | |
468 case 138: | |
469 jtt_bytecode_BC_ixor(); | |
470 break; | |
471 case 139: | |
472 jtt_bytecode_BC_l2d(); | |
473 break; | |
474 case 140: | |
475 jtt_bytecode_BC_l2f(); | |
476 break; | |
477 case 141: | |
478 jtt_bytecode_BC_l2i(); | |
479 break; | |
480 case 142: | |
481 jtt_bytecode_BC_ladd(); | |
482 break; | |
483 case 143: | |
484 jtt_bytecode_BC_ladd2(); | |
485 break; | |
486 case 144: | |
487 jtt_bytecode_BC_laload(); | |
488 break; | |
489 case 145: | |
490 jtt_bytecode_BC_land(); | |
491 break; | |
492 case 146: | |
493 jtt_bytecode_BC_lastore(); | |
494 break; | |
495 case 147: | |
496 jtt_bytecode_BC_lcmp(); | |
497 break; | |
498 case 148: | |
499 jtt_bytecode_BC_ldc_01(); | |
500 break; | |
501 case 149: | |
502 jtt_bytecode_BC_ldc_02(); | |
503 break; | |
504 case 150: | |
505 jtt_bytecode_BC_ldc_03(); | |
506 break; | |
507 case 151: | |
508 jtt_bytecode_BC_ldc_04(); | |
509 break; | |
510 case 152: | |
511 jtt_bytecode_BC_ldc_05(); | |
512 break; | |
513 case 153: | |
514 jtt_bytecode_BC_ldc_06(); | |
515 break; | |
516 case 154: | |
517 jtt_bytecode_BC_ldiv(); | |
518 break; | |
519 case 155: | |
520 jtt_bytecode_BC_ldiv2(); | |
521 break; | |
522 case 156: | |
523 jtt_bytecode_BC_lload_0(); | |
524 break; | |
525 case 157: | |
526 jtt_bytecode_BC_lload_01(); | |
527 break; | |
528 case 158: | |
529 jtt_bytecode_BC_lload_1(); | |
530 break; | |
531 case 159: | |
532 jtt_bytecode_BC_lload_2(); | |
533 break; | |
534 case 160: | |
535 jtt_bytecode_BC_lload_3(); | |
536 break; | |
537 case 161: | |
538 jtt_bytecode_BC_lmul(); | |
539 break; | |
540 case 162: | |
541 jtt_bytecode_BC_lneg(); | |
542 break; | |
543 case 163: | |
544 jtt_bytecode_BC_lookupswitch01(); | |
545 break; | |
546 case 164: | |
547 jtt_bytecode_BC_lookupswitch02(); | |
548 break; | |
549 case 165: | |
550 jtt_bytecode_BC_lookupswitch03(); | |
551 break; | |
552 case 166: | |
553 jtt_bytecode_BC_lookupswitch04(); | |
554 break; | |
555 case 167: | |
556 jtt_bytecode_BC_lor(); | |
557 break; | |
558 case 168: | |
559 jtt_bytecode_BC_lrem(); | |
560 break; | |
561 case 169: | |
562 jtt_bytecode_BC_lrem2(); | |
563 break; | |
564 case 170: | |
565 jtt_bytecode_BC_lreturn(); | |
566 break; | |
567 case 171: | |
568 jtt_bytecode_BC_lshl(); | |
569 break; | |
570 case 172: | |
571 jtt_bytecode_BC_lshr(); | |
572 break; | |
573 case 173: | |
574 jtt_bytecode_BC_lsub(); | |
575 break; | |
576 case 174: | |
577 jtt_bytecode_BC_lushr(); | |
578 break; | |
579 case 175: | |
580 jtt_bytecode_BC_lxor(); | |
581 break; | |
582 case 176: | |
583 jtt_bytecode_BC_monitorenter(); | |
584 break; | |
585 case 177: | |
586 jtt_bytecode_BC_monitorenter02(); | |
587 break; | |
588 case 178: | |
589 jtt_bytecode_BC_multianewarray01(); | |
590 break; | |
591 case 179: | |
592 jtt_bytecode_BC_multianewarray02(); | |
593 break; | |
594 case 180: | |
595 jtt_bytecode_BC_multianewarray03(); | |
596 break; | |
597 case 181: | |
598 jtt_bytecode_BC_multianewarray04(); | |
599 break; | |
600 case 182: | |
601 jtt_bytecode_BC_new(); | |
602 break; | |
603 case 183: | |
604 jtt_bytecode_BC_newarray(); | |
605 break; | |
606 case 184: | |
607 jtt_bytecode_BC_putfield(); | |
608 break; | |
609 case 185: | |
610 jtt_bytecode_BC_putstatic(); | |
611 break; | |
612 case 186: | |
613 jtt_bytecode_BC_saload(); | |
614 break; | |
615 case 187: | |
616 jtt_bytecode_BC_sastore(); | |
617 break; | |
618 case 188: | |
619 jtt_bytecode_BC_tableswitch(); | |
620 break; | |
621 case 189: | |
622 jtt_bytecode_BC_tableswitch2(); | |
623 break; | |
624 case 190: | |
625 jtt_bytecode_BC_tableswitch3(); | |
626 break; | |
627 case 191: | |
628 jtt_bytecode_BC_tableswitch4(); | |
629 break; | |
630 case 192: | |
631 jtt_bytecode_BC_wide01(); | |
632 break; | |
633 case 193: | |
634 jtt_bytecode_BC_wide02(); | |
635 break; | |
636 case 194: | |
637 jtt_optimize_ArrayLength01(); | |
638 break; | |
639 case 195: | |
640 jtt_optimize_BC_idiv_16(); | |
641 break; | |
642 case 196: | |
643 jtt_optimize_BC_idiv_4(); | |
644 break; | |
645 case 197: | |
646 jtt_optimize_BC_imul_16(); | |
647 break; | |
648 case 198: | |
649 jtt_optimize_BC_imul_4(); | |
650 break; | |
651 case 199: | |
652 jtt_optimize_BC_ldiv_16(); | |
653 break; | |
654 case 200: | |
655 jtt_optimize_BC_ldiv_4(); | |
656 break; | |
657 case 201: | |
658 jtt_optimize_BC_lmul_16(); | |
659 break; | |
660 case 202: | |
661 jtt_optimize_BC_lmul_4(); | |
662 break; | |
663 case 203: | |
664 jtt_optimize_BC_lshr_C16(); | |
665 break; | |
666 case 204: | |
667 jtt_optimize_BC_lshr_C24(); | |
668 break; | |
669 case 205: | |
670 jtt_optimize_BC_lshr_C32(); | |
671 break; | |
672 case 206: | |
673 jtt_optimize_BlockSkip01(); | |
674 break; | |
675 case 207: | |
676 jtt_optimize_Cmov01(); | |
677 break; | |
678 case 208: | |
679 jtt_optimize_DeadCode01(); | |
680 break; | |
681 case 209: | |
682 jtt_optimize_Fold_Cast01(); | |
683 break; | |
684 case 210: | |
685 jtt_optimize_Fold_Convert01(); | |
686 break; | |
687 case 211: | |
688 jtt_optimize_Fold_Convert02(); | |
689 break; | |
690 case 212: | |
691 jtt_optimize_Fold_Convert03(); | |
692 break; | |
693 case 213: | |
694 jtt_optimize_Fold_Convert04(); | |
695 break; | |
696 case 214: | |
697 jtt_optimize_Fold_Double01(); | |
698 break; | |
699 case 215: | |
700 jtt_optimize_Fold_Double02(); | |
701 break; | |
702 case 216: | |
703 jtt_optimize_Fold_Float01(); | |
704 break; | |
705 case 217: | |
706 jtt_optimize_Fold_Float02(); | |
707 break; | |
708 case 218: | |
709 jtt_optimize_Fold_InstanceOf01(); | |
710 break; | |
711 case 219: | |
712 jtt_optimize_Fold_Int01(); | |
713 break; | |
714 case 220: | |
715 jtt_optimize_Fold_Int02(); | |
716 break; | |
717 case 221: | |
718 jtt_optimize_Fold_Long01(); | |
719 break; | |
720 case 222: | |
721 jtt_optimize_Fold_Long02(); | |
722 break; | |
723 case 223: | |
724 jtt_optimize_Fold_Math01(); | |
725 break; | |
726 case 224: | |
727 jtt_optimize_Inline01(); | |
728 break; | |
729 case 225: | |
730 jtt_optimize_Inline02(); | |
731 break; | |
732 case 226: | |
733 jtt_optimize_List_reorder_bug(); | |
734 break; | |
735 case 227: | |
736 jtt_optimize_NCE_01(); | |
737 break; | |
738 case 228: | |
739 jtt_optimize_NCE_02(); | |
740 break; | |
741 case 229: | |
742 jtt_optimize_NCE_03(); | |
743 break; | |
744 case 230: | |
745 jtt_optimize_NCE_04(); | |
746 break; | |
747 case 231: | |
748 jtt_optimize_NCE_FlowSensitive01(); | |
749 break; | |
750 case 232: | |
751 jtt_optimize_NCE_FlowSensitive02(); | |
752 break; | |
753 case 233: | |
754 jtt_optimize_NCE_FlowSensitive03(); | |
755 break; | |
756 case 234: | |
757 jtt_optimize_NCE_FlowSensitive04(); | |
758 break; | |
759 case 235: | |
760 jtt_optimize_Narrow_byte01(); | |
761 break; | |
762 case 236: | |
763 jtt_optimize_Narrow_byte02(); | |
764 break; | |
765 case 237: | |
766 jtt_optimize_Narrow_byte03(); | |
767 break; | |
768 case 238: | |
769 jtt_optimize_Narrow_char01(); | |
770 break; | |
771 case 239: | |
772 jtt_optimize_Narrow_char02(); | |
773 break; | |
774 case 240: | |
775 jtt_optimize_Narrow_char03(); | |
776 break; | |
777 case 241: | |
778 jtt_optimize_Narrow_short01(); | |
779 break; | |
780 case 242: | |
781 jtt_optimize_Narrow_short02(); | |
782 break; | |
783 case 243: | |
784 jtt_optimize_Narrow_short03(); | |
785 break; | |
786 case 244: | |
787 jtt_optimize_Phi01(); | |
788 break; | |
789 case 245: | |
790 jtt_optimize_Phi02(); | |
791 break; | |
792 case 246: | |
793 jtt_optimize_Phi03(); | |
794 break; | |
795 case 247: | |
796 jtt_optimize_Reduce_Convert01(); | |
797 break; | |
798 case 248: | |
799 jtt_optimize_Reduce_Double01(); | |
800 break; | |
801 case 249: | |
802 jtt_optimize_Reduce_Float01(); | |
803 break; | |
804 case 250: | |
805 jtt_optimize_Reduce_Int01(); | |
806 break; | |
807 case 251: | |
808 jtt_optimize_Reduce_Int02(); | |
809 break; | |
810 case 252: | |
811 jtt_optimize_Reduce_Int03(); | |
812 break; | |
813 case 253: | |
814 jtt_optimize_Reduce_Int04(); | |
815 break; | |
816 case 254: | |
817 jtt_optimize_Reduce_IntShift01(); | |
818 break; | |
819 case 255: | |
820 jtt_optimize_Reduce_IntShift02(); | |
821 break; | |
822 case 256: | |
823 jtt_optimize_Reduce_Long01(); | |
824 break; | |
825 case 257: | |
826 jtt_optimize_Reduce_Long02(); | |
827 break; | |
828 case 258: | |
829 jtt_optimize_Reduce_Long03(); | |
830 break; | |
831 case 259: | |
832 jtt_optimize_Reduce_Long04(); | |
833 break; | |
834 case 260: | |
835 jtt_optimize_Reduce_LongShift01(); | |
836 break; | |
837 case 261: | |
838 jtt_optimize_Reduce_LongShift02(); | |
839 break; | |
840 case 262: | |
841 jtt_optimize_Switch01(); | |
842 break; | |
843 case 263: | |
844 jtt_optimize_Switch02(); | |
845 break; | |
846 case 264: | |
847 jtt_optimize_TypeCastElem(); | |
848 break; | |
849 case 265: | |
850 jtt_optimize_VN_Cast01(); | |
851 break; | |
852 case 266: | |
853 jtt_optimize_VN_Cast02(); | |
854 break; | |
855 case 267: | |
856 jtt_optimize_VN_Convert01(); | |
857 break; | |
858 case 268: | |
859 jtt_optimize_VN_Convert02(); | |
860 break; | |
861 case 269: | |
862 jtt_optimize_VN_Double01(); | |
863 break; | |
864 case 270: | |
865 jtt_optimize_VN_Double02(); | |
866 break; | |
867 case 271: | |
868 jtt_optimize_VN_Field01(); | |
869 break; | |
870 case 272: | |
871 jtt_optimize_VN_Field02(); | |
872 break; | |
873 case 273: | |
874 jtt_optimize_VN_Float01(); | |
875 break; | |
876 case 274: | |
877 jtt_optimize_VN_Float02(); | |
878 break; | |
879 case 275: | |
880 jtt_optimize_VN_InstanceOf01(); | |
881 break; | |
882 case 276: | |
883 jtt_optimize_VN_InstanceOf02(); | |
884 break; | |
885 case 277: | |
886 jtt_optimize_VN_InstanceOf03(); | |
887 break; | |
888 case 278: | |
889 jtt_optimize_VN_Int01(); | |
890 break; | |
891 case 279: | |
892 jtt_optimize_VN_Int02(); | |
893 break; | |
894 case 280: | |
895 jtt_optimize_VN_Int03(); | |
896 break; | |
897 case 281: | |
898 jtt_optimize_VN_Long01(); | |
899 break; | |
900 case 282: | |
901 jtt_optimize_VN_Long02(); | |
902 break; | |
903 case 283: | |
904 jtt_optimize_VN_Long03(); | |
905 break; | |
906 case 284: | |
907 jtt_optimize_VN_Loop01(); | |
908 break; | |
909 case 285: | |
910 jtt_except_BC_aaload0(); | |
911 break; | |
912 case 286: | |
913 jtt_except_BC_aaload1(); | |
914 break; | |
915 case 287: | |
916 jtt_except_BC_aastore0(); | |
917 break; | |
918 case 288: | |
919 jtt_except_BC_aastore1(); | |
920 break; | |
921 case 289: | |
922 jtt_except_BC_anewarray(); | |
923 break; | |
924 case 290: | |
925 jtt_except_BC_arraylength(); | |
926 break; | |
927 case 291: | |
928 jtt_except_BC_athrow0(); | |
929 break; | |
930 case 292: | |
931 jtt_except_BC_athrow1(); | |
932 break; | |
933 case 293: | |
934 jtt_except_BC_athrow2(); | |
935 break; | |
936 case 294: | |
937 jtt_except_BC_athrow3(); | |
938 break; | |
939 case 295: | |
940 jtt_except_BC_baload(); | |
941 break; | |
942 case 296: | |
943 jtt_except_BC_bastore(); | |
944 break; | |
945 case 297: | |
946 jtt_except_BC_caload(); | |
947 break; | |
948 case 298: | |
949 jtt_except_BC_castore(); | |
950 break; | |
951 case 299: | |
952 jtt_except_BC_checkcast(); | |
953 break; | |
954 case 300: | |
955 jtt_except_BC_checkcast1(); | |
956 break; | |
957 case 301: | |
958 jtt_except_BC_checkcast2(); | |
959 break; | |
960 case 302: | |
961 jtt_except_BC_checkcast3(); | |
962 break; | |
963 case 303: | |
964 jtt_except_BC_checkcast4(); | |
965 break; | |
966 case 304: | |
967 jtt_except_BC_checkcast5(); | |
968 break; | |
969 case 305: | |
970 jtt_except_BC_checkcast6(); | |
971 break; | |
972 case 306: | |
973 jtt_except_BC_daload(); | |
974 break; | |
975 case 307: | |
976 jtt_except_BC_dastore(); | |
977 break; | |
978 case 308: | |
979 jtt_except_BC_faload(); | |
980 break; | |
981 case 309: | |
982 jtt_except_BC_fastore(); | |
983 break; | |
984 case 310: | |
985 jtt_except_BC_getfield(); | |
986 break; | |
987 case 311: | |
988 jtt_except_BC_iaload(); | |
989 break; | |
990 case 312: | |
991 jtt_except_BC_iastore(); | |
992 break; | |
993 case 313: | |
994 jtt_except_BC_idiv(); | |
995 break; | |
996 case 314: | |
997 jtt_except_BC_idiv2(); | |
998 break; | |
999 case 315: | |
1000 jtt_except_BC_invokespecial01(); | |
1001 break; | |
1002 case 316: | |
1003 jtt_except_BC_invokevirtual01(); | |
1004 break; | |
1005 case 317: | |
1006 jtt_except_BC_invokevirtual02(); | |
1007 break; | |
1008 case 318: | |
1009 jtt_except_BC_irem(); | |
1010 break; | |
1011 case 319: | |
1012 jtt_except_BC_laload(); | |
1013 break; | |
1014 case 320: | |
1015 jtt_except_BC_lastore(); | |
1016 break; | |
1017 case 321: | |
1018 jtt_except_BC_ldiv(); | |
1019 break; | |
1020 case 322: | |
1021 jtt_except_BC_ldiv2(); | |
1022 break; | |
1023 case 323: | |
1024 jtt_except_BC_lrem(); | |
1025 break; | |
1026 case 324: | |
1027 jtt_except_BC_monitorenter(); | |
1028 break; | |
1029 case 325: | |
1030 jtt_except_BC_multianewarray(); | |
1031 break; | |
1032 case 326: | |
1033 jtt_except_BC_newarray(); | |
1034 break; | |
1035 case 327: | |
1036 jtt_except_BC_putfield(); | |
1037 break; | |
1038 case 328: | |
1039 jtt_except_BC_saload(); | |
1040 break; | |
1041 case 329: | |
1042 jtt_except_BC_sastore(); | |
1043 break; | |
1044 case 330: | |
1045 jtt_except_Catch_Loop01(); | |
1046 break; | |
1047 case 331: | |
1048 jtt_except_Catch_Loop02(); | |
1049 break; | |
1050 case 332: | |
1051 jtt_except_Catch_NASE_1(); | |
1052 break; | |
1053 case 333: | |
1054 jtt_except_Catch_NASE_2(); | |
1055 break; | |
1056 case 334: | |
1057 jtt_except_Catch_NPE_00(); | |
1058 break; | |
1059 case 335: | |
1060 jtt_except_Catch_NPE_01(); | |
1061 break; | |
1062 case 336: | |
1063 jtt_except_Catch_NPE_02(); | |
1064 break; | |
1065 case 337: | |
1066 jtt_except_Catch_NPE_03(); | |
1067 break; | |
1068 case 338: | |
1069 jtt_except_Catch_NPE_04(); | |
1070 break; | |
1071 case 339: | |
1072 jtt_except_Catch_NPE_05(); | |
1073 break; | |
1074 case 340: | |
1075 jtt_except_Catch_NPE_06(); | |
1076 break; | |
1077 case 341: | |
1078 jtt_except_Catch_NPE_07(); | |
1079 break; | |
1080 case 342: | |
1081 jtt_except_Catch_NPE_08(); | |
1082 break; | |
1083 case 343: | |
1084 jtt_except_Catch_NPE_09(); | |
1085 break; | |
1086 case 344: | |
1087 jtt_except_Catch_NPE_10(); | |
1088 break; | |
1089 case 345: | |
1090 jtt_except_Catch_NPE_11(); | |
1091 break; | |
1092 case 346: | |
1093 jtt_except_Catch_StackOverflowError_01(); | |
1094 break; | |
1095 case 347: | |
1096 jtt_except_Catch_StackOverflowError_02(); | |
1097 break; | |
1098 case 348: | |
1099 jtt_except_Catch_StackOverflowError_03(); | |
1100 break; | |
1101 case 349: | |
1102 jtt_except_Catch_Two01(); | |
1103 break; | |
1104 case 350: | |
1105 jtt_except_Catch_Two02(); | |
1106 break; | |
1107 case 351: | |
1108 jtt_except_Catch_Two03(); | |
1109 break; | |
1110 case 352: | |
1111 jtt_except_Except_Synchronized01(); | |
1112 break; | |
1113 case 353: | |
1114 jtt_except_Except_Synchronized02(); | |
1115 break; | |
1116 case 354: | |
1117 jtt_except_Except_Synchronized03(); | |
1118 break; | |
1119 case 355: | |
1120 jtt_except_Except_Synchronized04(); | |
1121 break; | |
1122 case 356: | |
1123 jtt_except_Except_Synchronized05(); | |
1124 break; | |
1125 case 357: | |
1126 jtt_except_Finally01(); | |
1127 break; | |
1128 case 358: | |
1129 jtt_except_Finally02(); | |
1130 break; | |
1131 case 359: | |
1132 jtt_except_StackTrace_AIOOBE_00(); | |
1133 break; | |
1134 case 360: | |
1135 jtt_except_StackTrace_CCE_00(); | |
1136 break; | |
1137 case 361: | |
1138 jtt_except_StackTrace_NPE_00(); | |
1139 break; | |
1140 case 362: | |
1141 jtt_except_StackTrace_NPE_01(); | |
1142 break; | |
1143 case 363: | |
1144 jtt_except_StackTrace_NPE_02(); | |
1145 break; | |
1146 case 364: | |
1147 jtt_except_StackTrace_NPE_03(); | |
1148 break; | |
1149 case 365: | |
1150 jtt_except_Throw_InCatch01(); | |
1151 break; | |
1152 case 366: | |
1153 jtt_except_Throw_InCatch02(); | |
1154 break; | |
1155 case 367: | |
1156 jtt_except_Throw_InCatch03(); | |
1157 break; | |
1158 case 368: | |
1159 jtt_except_Throw_NPE_01(); | |
1160 break; | |
1161 case 369: | |
1162 jtt_except_Throw_Synchronized01(); | |
1163 break; | |
1164 case 370: | |
1165 jtt_except_Throw_Synchronized02(); | |
1166 break; | |
1167 case 371: | |
1168 jtt_except_Throw_Synchronized03(); | |
1169 break; | |
1170 case 372: | |
1171 jtt_except_Throw_Synchronized04(); | |
1172 break; | |
1173 case 373: | |
1174 jtt_except_Throw_Synchronized05(); | |
1175 break; | |
1176 case 374: | |
1177 jtt_lang_Boxed_TYPE_01(); | |
1178 break; | |
1179 case 375: | |
1180 jtt_lang_Bridge_method01(); | |
1181 break; | |
1182 case 376: | |
1183 jtt_lang_ClassLoader_loadClass01(); | |
1184 break; | |
1185 case 377: | |
1186 jtt_lang_Class_Literal01(); | |
1187 break; | |
1188 case 378: | |
1189 jtt_lang_Class_asSubclass01(); | |
1190 break; | |
1191 case 379: | |
1192 jtt_lang_Class_cast01(); | |
1193 break; | |
1194 case 380: | |
1195 jtt_lang_Class_cast02(); | |
1196 break; | |
1197 case 381: | |
1198 jtt_lang_Class_forName01(); | |
1199 break; | |
1200 case 382: | |
1201 jtt_lang_Class_forName02(); | |
1202 break; | |
1203 case 383: | |
1204 jtt_lang_Class_forName03(); | |
1205 break; | |
1206 case 384: | |
1207 jtt_lang_Class_forName04(); | |
1208 break; | |
1209 case 385: | |
1210 jtt_lang_Class_forName05(); | |
1211 break; | |
1212 case 386: | |
1213 jtt_lang_Class_getComponentType01(); | |
1214 break; | |
1215 case 387: | |
1216 jtt_lang_Class_getInterfaces01(); | |
1217 break; | |
1218 case 388: | |
1219 jtt_lang_Class_getName01(); | |
1220 break; | |
1221 case 389: | |
1222 jtt_lang_Class_getName02(); | |
1223 break; | |
1224 case 390: | |
1225 jtt_lang_Class_getSimpleName01(); | |
1226 break; | |
1227 case 391: | |
1228 jtt_lang_Class_getSimpleName02(); | |
1229 break; | |
1230 case 392: | |
1231 jtt_lang_Class_getSuperClass01(); | |
1232 break; | |
1233 case 393: | |
1234 jtt_lang_Class_isArray01(); | |
1235 break; | |
1236 case 394: | |
1237 jtt_lang_Class_isAssignableFrom01(); | |
1238 break; | |
1239 case 395: | |
1240 jtt_lang_Class_isAssignableFrom02(); | |
1241 break; | |
1242 case 396: | |
1243 jtt_lang_Class_isAssignableFrom03(); | |
1244 break; | |
1245 case 397: | |
1246 jtt_lang_Class_isInstance01(); | |
1247 break; | |
1248 case 398: | |
1249 jtt_lang_Class_isInstance02(); | |
1250 break; | |
1251 case 399: | |
1252 jtt_lang_Class_isInstance03(); | |
1253 break; | |
1254 case 400: | |
1255 jtt_lang_Class_isInstance04(); | |
1256 break; | |
1257 case 401: | |
1258 jtt_lang_Class_isInstance05(); | |
1259 break; | |
1260 case 402: | |
1261 jtt_lang_Class_isInstance06(); | |
1262 break; | |
1263 case 403: | |
1264 jtt_lang_Class_isInterface01(); | |
1265 break; | |
1266 case 404: | |
1267 jtt_lang_Class_isPrimitive01(); | |
1268 break; | |
1269 case 405: | |
1270 jtt_lang_Double_toString(); | |
1271 break; | |
1272 case 406: | |
1273 jtt_lang_Float_01(); | |
1274 break; | |
1275 case 407: | |
1276 jtt_lang_Float_02(); | |
1277 break; | |
1278 case 408: | |
1279 jtt_lang_Int_greater01(); | |
1280 break; | |
1281 case 409: | |
1282 jtt_lang_Int_greater02(); | |
1283 break; | |
1284 case 410: | |
1285 jtt_lang_Int_greater03(); | |
1286 break; | |
1287 case 411: | |
1288 jtt_lang_Int_greaterEqual01(); | |
1289 break; | |
1290 case 412: | |
1291 jtt_lang_Int_greaterEqual02(); | |
1292 break; | |
1293 case 413: | |
1294 jtt_lang_Int_greaterEqual03(); | |
1295 break; | |
1296 case 414: | |
1297 jtt_lang_Int_less01(); | |
1298 break; | |
1299 case 415: | |
1300 jtt_lang_Int_less02(); | |
1301 break; | |
1302 case 416: | |
1303 jtt_lang_Int_less03(); | |
1304 break; | |
1305 case 417: | |
1306 jtt_lang_Int_lessEqual01(); | |
1307 break; | |
1308 case 418: | |
1309 jtt_lang_Int_lessEqual02(); | |
1310 break; | |
1311 case 419: | |
1312 jtt_lang_Int_lessEqual03(); | |
1313 break; | |
1314 case 420: | |
1315 jtt_lang_JDK_ClassLoaders01(); | |
1316 break; | |
1317 case 421: | |
1318 jtt_lang_JDK_ClassLoaders02(); | |
1319 break; | |
1320 case 422: | |
1321 jtt_lang_Long_greater01(); | |
1322 break; | |
1323 case 423: | |
1324 jtt_lang_Long_greater02(); | |
1325 break; | |
1326 case 424: | |
1327 jtt_lang_Long_greater03(); | |
1328 break; | |
1329 case 425: | |
1330 jtt_lang_Long_greaterEqual01(); | |
1331 break; | |
1332 case 426: | |
1333 jtt_lang_Long_greaterEqual02(); | |
1334 break; | |
1335 case 427: | |
1336 jtt_lang_Long_greaterEqual03(); | |
1337 break; | |
1338 case 428: | |
1339 jtt_lang_Long_less01(); | |
1340 break; | |
1341 case 429: | |
1342 jtt_lang_Long_less02(); | |
1343 break; | |
1344 case 430: | |
1345 jtt_lang_Long_less03(); | |
1346 break; | |
1347 case 431: | |
1348 jtt_lang_Long_lessEqual01(); | |
1349 break; | |
1350 case 432: | |
1351 jtt_lang_Long_lessEqual02(); | |
1352 break; | |
1353 case 433: | |
1354 jtt_lang_Long_lessEqual03(); | |
1355 break; | |
1356 case 434: | |
1357 jtt_lang_Long_reverseBytes01(); | |
1358 break; | |
1359 case 435: | |
1360 jtt_lang_Long_reverseBytes02(); | |
1361 break; | |
1362 case 436: | |
1363 jtt_lang_Math_pow(); | |
1364 break; | |
1365 case 437: | |
1366 jtt_lang_Object_clone01(); | |
1367 break; | |
1368 case 438: | |
1369 jtt_lang_Object_clone02(); | |
1370 break; | |
1371 case 439: | |
1372 jtt_lang_Object_equals01(); | |
1373 break; | |
1374 case 440: | |
1375 jtt_lang_Object_getClass01(); | |
1376 break; | |
1377 case 441: | |
1378 jtt_lang_Object_hashCode01(); | |
1379 break; | |
1380 case 442: | |
1381 jtt_lang_Object_notify01(); | |
1382 break; | |
1383 case 443: | |
1384 jtt_lang_Object_notify02(); | |
1385 break; | |
1386 case 444: | |
1387 jtt_lang_Object_notifyAll01(); | |
1388 break; | |
1389 case 445: | |
1390 jtt_lang_Object_notifyAll02(); | |
1391 break; | |
1392 case 446: | |
1393 jtt_lang_Object_toString01(); | |
1394 break; | |
1395 case 447: | |
1396 jtt_lang_Object_toString02(); | |
1397 break; | |
1398 case 448: | |
1399 jtt_lang_Object_wait01(); | |
1400 break; | |
1401 case 449: | |
1402 jtt_lang_Object_wait02(); | |
1403 break; | |
1404 case 450: | |
1405 jtt_lang_Object_wait03(); | |
1406 break; | |
1407 case 451: | |
1408 jtt_lang_ProcessEnvironment_init(); | |
1409 break; | |
1410 case 452: | |
1411 jtt_lang_StringCoding_Scale(); | |
1412 break; | |
1413 case 453: | |
1414 jtt_lang_String_intern01(); | |
1415 break; | |
1416 case 454: | |
1417 jtt_lang_String_intern02(); | |
1418 break; | |
1419 case 455: | |
1420 jtt_lang_String_intern03(); | |
1421 break; | |
1422 case 456: | |
1423 jtt_lang_String_valueOf01(); | |
1424 break; | |
1425 case 457: | |
1426 jtt_lang_System_identityHashCode01(); | |
1427 break; | |
1428 case 458: | |
1429 jtt_micro_ArrayCompare01(); | |
1430 break; | |
1431 case 459: | |
1432 jtt_micro_ArrayCompare02(); | |
1433 break; | |
1434 case 460: | |
1435 jtt_micro_BC_invokevirtual2(); | |
1436 break; | |
1437 case 461: | |
1438 jtt_micro_BigByteParams01(); | |
1439 break; | |
1440 case 462: | |
1441 jtt_micro_BigDoubleParams02(); | |
1442 break; | |
1443 case 463: | |
1444 jtt_micro_BigFloatParams01(); | |
1445 break; | |
1446 case 464: | |
1447 jtt_micro_BigFloatParams02(); | |
1448 break; | |
1449 case 465: | |
1450 jtt_micro_BigIntParams01(); | |
1451 break; | |
1452 case 466: | |
1453 jtt_micro_BigIntParams02(); | |
1454 break; | |
1455 case 467: | |
1456 jtt_micro_BigInterfaceParams01(); | |
1457 break; | |
1458 case 468: | |
1459 jtt_micro_BigLongParams02(); | |
1460 break; | |
1461 case 469: | |
1462 jtt_micro_BigMixedParams01(); | |
1463 break; | |
1464 case 470: | |
1465 jtt_micro_BigMixedParams02(); | |
1466 break; | |
1467 case 471: | |
1468 jtt_micro_BigMixedParams03(); | |
1469 break; | |
1470 case 472: | |
1471 jtt_micro_BigObjectParams01(); | |
1472 break; | |
1473 case 473: | |
1474 jtt_micro_BigObjectParams02(); | |
1475 break; | |
1476 case 474: | |
1477 jtt_micro_BigParamsAlignment(); | |
1478 break; | |
1479 case 475: | |
1480 jtt_micro_BigShortParams01(); | |
1481 break; | |
1482 case 476: | |
1483 jtt_micro_BigVirtualParams01(); | |
1484 break; | |
1485 case 477: | |
1486 jtt_micro_Bubblesort(); | |
1487 break; | |
1488 case 478: | |
1489 jtt_micro_Fibonacci(); | |
1490 break; | |
1491 case 479: | |
1492 jtt_micro_InvokeVirtual_01(); | |
1493 break; | |
1494 case 480: | |
1495 jtt_micro_InvokeVirtual_02(); | |
1496 break; | |
1497 case 481: | |
1498 jtt_micro_Matrix01(); | |
1499 break; | |
1500 case 482: | |
1501 jtt_micro_StrangeFrames(); | |
1502 break; | |
1503 case 483: | |
1504 jtt_micro_String_format01(); | |
1505 break; | |
1506 case 484: | |
1507 jtt_micro_String_format02(); | |
1508 break; | |
1509 case 485: | |
1510 jtt_micro_VarArgs_String01(); | |
1511 break; | |
1512 case 486: | |
1513 jtt_micro_VarArgs_boolean01(); | |
1514 break; | |
1515 case 487: | |
1516 jtt_micro_VarArgs_byte01(); | |
1517 break; | |
1518 case 488: | |
1519 jtt_micro_VarArgs_char01(); | |
1520 break; | |
1521 case 489: | |
1522 jtt_micro_VarArgs_double01(); | |
1523 break; | |
1524 case 490: | |
1525 jtt_micro_VarArgs_float01(); | |
1526 break; | |
1527 case 491: | |
1528 jtt_micro_VarArgs_int01(); | |
1529 break; | |
1530 case 492: | |
1531 jtt_micro_VarArgs_long01(); | |
1532 break; | |
1533 case 493: | |
1534 jtt_micro_VarArgs_short01(); | |
1535 break; | |
1536 case 494: | |
1537 jtt_reflect_Array_get01(); | |
1538 break; | |
1539 case 495: | |
1540 jtt_reflect_Array_get02(); | |
1541 break; | |
1542 case 496: | |
1543 jtt_reflect_Array_get03(); | |
1544 break; | |
1545 case 497: | |
1546 jtt_reflect_Array_getBoolean01(); | |
1547 break; | |
1548 case 498: | |
1549 jtt_reflect_Array_getByte01(); | |
1550 break; | |
1551 case 499: | |
1552 jtt_reflect_Array_getChar01(); | |
1553 break; | |
1554 case 500: | |
1555 jtt_reflect_Array_getDouble01(); | |
1556 break; | |
1557 case 501: | |
1558 jtt_reflect_Array_getFloat01(); | |
1559 break; | |
1560 case 502: | |
1561 jtt_reflect_Array_getInt01(); | |
1562 break; | |
1563 case 503: | |
1564 jtt_reflect_Array_getLength01(); | |
1565 break; | |
1566 case 504: | |
1567 jtt_reflect_Array_getLong01(); | |
1568 break; | |
1569 case 505: | |
1570 jtt_reflect_Array_getShort01(); | |
1571 break; | |
1572 case 506: | |
1573 jtt_reflect_Array_newInstance01(); | |
1574 break; | |
1575 case 507: | |
1576 jtt_reflect_Array_newInstance02(); | |
1577 break; | |
1578 case 508: | |
1579 jtt_reflect_Array_newInstance03(); | |
1580 break; | |
1581 case 509: | |
1582 jtt_reflect_Array_newInstance04(); | |
1583 break; | |
1584 case 510: | |
1585 jtt_reflect_Array_newInstance05(); | |
1586 break; | |
1587 case 511: | |
1588 jtt_reflect_Array_newInstance06(); | |
1589 break; | |
1590 case 512: | |
1591 jtt_reflect_Array_set01(); | |
1592 break; | |
1593 case 513: | |
1594 jtt_reflect_Array_set02(); | |
1595 break; | |
1596 case 514: | |
1597 jtt_reflect_Array_set03(); | |
1598 break; | |
1599 case 515: | |
1600 jtt_reflect_Array_setBoolean01(); | |
1601 break; | |
1602 case 516: | |
1603 jtt_reflect_Array_setByte01(); | |
1604 break; | |
1605 case 517: | |
1606 jtt_reflect_Array_setChar01(); | |
1607 break; | |
1608 case 518: | |
1609 jtt_reflect_Array_setDouble01(); | |
1610 break; | |
1611 case 519: | |
1612 jtt_reflect_Array_setFloat01(); | |
1613 break; | |
1614 case 520: | |
1615 jtt_reflect_Array_setInt01(); | |
1616 break; | |
1617 case 521: | |
1618 jtt_reflect_Array_setLong01(); | |
1619 break; | |
1620 case 522: | |
1621 jtt_reflect_Array_setShort01(); | |
1622 break; | |
1623 case 523: | |
1624 jtt_reflect_Class_getDeclaredField01(); | |
1625 break; | |
1626 case 524: | |
1627 jtt_reflect_Class_getDeclaredMethod01(); | |
1628 break; | |
1629 case 525: | |
1630 jtt_reflect_Class_getField01(); | |
1631 break; | |
1632 case 526: | |
1633 jtt_reflect_Class_getField02(); | |
1634 break; | |
1635 case 527: | |
1636 jtt_reflect_Class_getMethod01(); | |
1637 break; | |
1638 case 528: | |
1639 jtt_reflect_Class_getMethod02(); | |
1640 break; | |
1641 case 529: | |
1642 jtt_reflect_Class_newInstance01(); | |
1643 break; | |
1644 case 530: | |
1645 jtt_reflect_Class_newInstance02(); | |
1646 break; | |
1647 case 531: | |
1648 jtt_reflect_Class_newInstance03(); | |
1649 break; | |
1650 case 532: | |
1651 jtt_reflect_Class_newInstance06(); | |
1652 break; | |
1653 case 533: | |
1654 jtt_reflect_Class_newInstance07(); | |
1655 break; | |
1656 case 534: | |
1657 jtt_reflect_Field_get01(); | |
1658 break; | |
1659 case 535: | |
1660 jtt_reflect_Field_get02(); | |
1661 break; | |
1662 case 536: | |
1663 jtt_reflect_Field_get03(); | |
1664 break; | |
1665 case 537: | |
1666 jtt_reflect_Field_get04(); | |
1667 break; | |
1668 case 538: | |
1669 jtt_reflect_Field_getType01(); | |
1670 break; | |
1671 case 539: | |
1672 jtt_reflect_Field_set01(); | |
1673 break; | |
1674 case 540: | |
1675 jtt_reflect_Field_set02(); | |
1676 break; | |
1677 case 541: | |
1678 jtt_reflect_Field_set03(); | |
1679 break; | |
1680 case 542: | |
1681 jtt_reflect_Invoke_except01(); | |
1682 break; | |
1683 case 543: | |
1684 jtt_reflect_Invoke_main01(); | |
1685 break; | |
1686 case 544: | |
1687 jtt_reflect_Invoke_main02(); | |
1688 break; | |
1689 case 545: | |
1690 jtt_reflect_Invoke_main03(); | |
1691 break; | |
1692 case 546: | |
1693 jtt_reflect_Invoke_virtual01(); | |
1694 break; | |
1695 case 547: | |
1696 jtt_reflect_Method_getParameterTypes01(); | |
1697 break; | |
1698 case 548: | |
1699 jtt_reflect_Method_getReturnType01(); | |
1700 break; | |
1701 case 549: | |
1702 jtt_reflect_Reflection_getCallerClass01(); | |
1703 break; | |
1704 case 550: | |
1705 jtt_threads_Monitor_contended01(); | |
1706 break; | |
1707 case 551: | |
1708 jtt_threads_Monitor_notowner01(); | |
1709 break; | |
1710 case 552: | |
1711 jtt_threads_Monitorenter01(); | |
1712 break; | |
1713 case 553: | |
1714 jtt_threads_Monitorenter02(); | |
1715 break; | |
1716 case 554: | |
1717 jtt_threads_Object_wait01(); | |
1718 break; | |
1719 case 555: | |
1720 jtt_threads_Object_wait02(); | |
1721 break; | |
1722 case 556: | |
1723 jtt_threads_Object_wait03(); | |
1724 break; | |
1725 case 557: | |
1726 jtt_threads_Object_wait04(); | |
1727 break; | |
1728 case 558: | |
1729 jtt_threads_ThreadLocal01(); | |
1730 break; | |
1731 case 559: | |
1732 jtt_threads_ThreadLocal02(); | |
1733 break; | |
1734 case 560: | |
1735 jtt_threads_ThreadLocal03(); | |
1736 break; | |
1737 case 561: | |
1738 jtt_threads_Thread_currentThread01(); | |
1739 break; | |
1740 case 562: | |
1741 jtt_threads_Thread_getState01(); | |
1742 break; | |
1743 case 563: | |
1744 jtt_threads_Thread_getState02(); | |
1745 break; | |
1746 case 564: | |
1747 jtt_threads_Thread_holdsLock01(); | |
1748 break; | |
1749 case 565: | |
1750 jtt_threads_Thread_isAlive01(); | |
1751 break; | |
1752 case 566: | |
1753 jtt_threads_Thread_isInterrupted01(); | |
1754 break; | |
1755 case 567: | |
1756 jtt_threads_Thread_isInterrupted02(); | |
1757 break; | |
1758 case 568: | |
1759 jtt_threads_Thread_isInterrupted03(); | |
1760 break; | |
1761 case 569: | |
1762 jtt_threads_Thread_isInterrupted04(); | |
1763 break; | |
1764 case 570: | |
1765 jtt_threads_Thread_isInterrupted05(); | |
1766 break; | |
1767 case 571: | |
1768 jtt_threads_Thread_join01(); | |
1769 break; | |
1770 case 572: | |
1771 jtt_threads_Thread_join02(); | |
1772 break; | |
1773 case 573: | |
1774 jtt_threads_Thread_join03(); | |
1775 break; | |
1776 case 574: | |
1777 jtt_threads_Thread_new01(); | |
1778 break; | |
1779 case 575: | |
1780 jtt_threads_Thread_new02(); | |
1781 break; | |
1782 case 576: | |
1783 jtt_threads_Thread_setPriority01(); | |
1784 break; | |
1785 case 577: | |
1786 jtt_threads_Thread_sleep01(); | |
1787 break; | |
1788 case 578: | |
1789 jtt_threads_Thread_start01(); | |
1790 break; | |
1791 case 579: | |
1792 jtt_threads_Thread_yield01(); | |
1793 break; | |
1794 case 580: | |
1795 jtt_jdk_Class_getName(); | |
1796 break; | |
1797 case 581: | |
1798 jtt_jdk_EnumMap01(); | |
1799 break; | |
1800 case 582: | |
1801 jtt_jdk_EnumMap02(); | |
1802 break; | |
1803 case 583: | |
1804 jtt_jdk_System_currentTimeMillis01(); | |
1805 break; | |
1806 case 584: | |
1807 jtt_jdk_System_currentTimeMillis02(); | |
1808 break; | |
1809 case 585: | |
1810 jtt_jdk_System_nanoTime01(); | |
1811 break; | |
1812 case 586: | |
1813 jtt_jdk_System_nanoTime02(); | |
1814 break; | |
1815 case 587: | |
1816 jtt_jdk_UnsafeAccess01(); | |
1817 break; | |
1818 } | |
1819 return true; | |
1820 } | |
1821 | |
1822 static void jtt_bytecode_BC_aaload() { | |
1823 begin("jtt.bytecode.BC_aaload"); | |
1824 String runString = null; | |
1825 try { | |
1826 // (0) == null | |
1827 runString = "(0)"; | |
1828 if (null != jtt.bytecode.BC_aaload.test(0)) { | |
1829 fail(runString); | |
1830 return; | |
1831 } | |
1832 // (1) == null | |
1833 runString = "(1)"; | |
1834 if (null != jtt.bytecode.BC_aaload.test(1)) { | |
1835 fail(runString); | |
1836 return; | |
1837 } | |
1838 // (2) == "" | |
1839 runString = "(2)"; | |
1840 if (!"".equals(jtt.bytecode.BC_aaload.test(2))) { | |
1841 fail(runString); | |
1842 return; | |
1843 } | |
1844 } catch (Throwable t) { | |
1845 fail(runString, t); | |
1846 return; | |
1847 } | |
1848 pass(); | |
1849 } | |
1850 | |
1851 static void jtt_bytecode_BC_aaload_1() { | |
1852 begin("jtt.bytecode.BC_aaload_1"); | |
1853 String runString = null; | |
1854 try { | |
1855 // (0) == null | |
1856 runString = "(0)"; | |
1857 if (null != jtt.bytecode.BC_aaload_1.test(0)) { | |
1858 fail(runString); | |
1859 return; | |
1860 } | |
1861 // (1) == null | |
1862 runString = "(1)"; | |
1863 if (null != jtt.bytecode.BC_aaload_1.test(1)) { | |
1864 fail(runString); | |
1865 return; | |
1866 } | |
1867 // (2) == "" | |
1868 runString = "(2)"; | |
1869 if (!"".equals(jtt.bytecode.BC_aaload_1.test(2))) { | |
1870 fail(runString); | |
1871 return; | |
1872 } | |
1873 } catch (Throwable t) { | |
1874 fail(runString, t); | |
1875 return; | |
1876 } | |
1877 pass(); | |
1878 } | |
1879 | |
1880 static void jtt_bytecode_BC_aastore() { | |
1881 begin("jtt.bytecode.BC_aastore"); | |
1882 String runString = null; | |
1883 try { | |
1884 // (true,0) == 0 | |
1885 runString = "(true,0)"; | |
1886 if (0 != jtt.bytecode.BC_aastore.test(true, 0)) { | |
1887 fail(runString); | |
1888 return; | |
1889 } | |
1890 // (true,1) == 1 | |
1891 runString = "(true,1)"; | |
1892 if (1 != jtt.bytecode.BC_aastore.test(true, 1)) { | |
1893 fail(runString); | |
1894 return; | |
1895 } | |
1896 // (true,2) == 2 | |
1897 runString = "(true,2)"; | |
1898 if (2 != jtt.bytecode.BC_aastore.test(true, 2)) { | |
1899 fail(runString); | |
1900 return; | |
1901 } | |
1902 // (false,1) == 1 | |
1903 runString = "(false,1)"; | |
1904 if (1 != jtt.bytecode.BC_aastore.test(false, 1)) { | |
1905 fail(runString); | |
1906 return; | |
1907 } | |
1908 // (false,2) == 2 | |
1909 runString = "(false,2)"; | |
1910 if (2 != jtt.bytecode.BC_aastore.test(false, 2)) { | |
1911 fail(runString); | |
1912 return; | |
1913 } | |
1914 } catch (Throwable t) { | |
1915 fail(runString, t); | |
1916 return; | |
1917 } | |
1918 pass(); | |
1919 } | |
1920 | |
1921 static void jtt_bytecode_BC_aload_0() { | |
1922 begin("jtt.bytecode.BC_aload_0"); | |
1923 String runString = null; | |
1924 try { | |
1925 // (null) == null | |
1926 runString = "(null)"; | |
1927 if (null != jtt.bytecode.BC_aload_0.test(null)) { | |
1928 fail(runString); | |
1929 return; | |
1930 } | |
1931 // ("x") == "x" | |
1932 runString = "(\"x\")"; | |
1933 if (!"x".equals(jtt.bytecode.BC_aload_0.test("x"))) { | |
1934 fail(runString); | |
1935 return; | |
1936 } | |
1937 } catch (Throwable t) { | |
1938 fail(runString, t); | |
1939 return; | |
1940 } | |
1941 pass(); | |
1942 } | |
1943 | |
1944 static void jtt_bytecode_BC_aload_1() { | |
1945 begin("jtt.bytecode.BC_aload_1"); | |
1946 String runString = null; | |
1947 try { | |
1948 // (1,null) == null | |
1949 runString = "(1,null)"; | |
1950 if (null != jtt.bytecode.BC_aload_1.test(1, null)) { | |
1951 fail(runString); | |
1952 return; | |
1953 } | |
1954 // (1,"x") == "x" | |
1955 runString = "(1,\"x\")"; | |
1956 if (!"x".equals(jtt.bytecode.BC_aload_1.test(1, "x"))) { | |
1957 fail(runString); | |
1958 return; | |
1959 } | |
1960 } catch (Throwable t) { | |
1961 fail(runString, t); | |
1962 return; | |
1963 } | |
1964 pass(); | |
1965 } | |
1966 | |
1967 static void jtt_bytecode_BC_aload_2() { | |
1968 begin("jtt.bytecode.BC_aload_2"); | |
1969 String runString = null; | |
1970 try { | |
1971 // (1,1,null) == null | |
1972 runString = "(1,1,null)"; | |
1973 if (null != jtt.bytecode.BC_aload_2.test(1, 1, null)) { | |
1974 fail(runString); | |
1975 return; | |
1976 } | |
1977 // (1,1,"x") == "x" | |
1978 runString = "(1,1,\"x\")"; | |
1979 if (!"x".equals(jtt.bytecode.BC_aload_2.test(1, 1, "x"))) { | |
1980 fail(runString); | |
1981 return; | |
1982 } | |
1983 } catch (Throwable t) { | |
1984 fail(runString, t); | |
1985 return; | |
1986 } | |
1987 pass(); | |
1988 } | |
1989 | |
1990 static void jtt_bytecode_BC_aload_3() { | |
1991 begin("jtt.bytecode.BC_aload_3"); | |
1992 String runString = null; | |
1993 try { | |
1994 // (1,1,1,"x") == "x" | |
1995 runString = "(1,1,1,\"x\")"; | |
1996 if (!"x".equals(jtt.bytecode.BC_aload_3.test(1, 1, 1, "x"))) { | |
1997 fail(runString); | |
1998 return; | |
1999 } | |
2000 // (1,1,1,null) == null | |
2001 runString = "(1,1,1,null)"; | |
2002 if (null != jtt.bytecode.BC_aload_3.test(1, 1, 1, null)) { | |
2003 fail(runString); | |
2004 return; | |
2005 } | |
2006 } catch (Throwable t) { | |
2007 fail(runString, t); | |
2008 return; | |
2009 } | |
2010 pass(); | |
2011 } | |
2012 | |
2013 static void jtt_bytecode_BC_anewarray() { | |
2014 begin("jtt.bytecode.BC_anewarray"); | |
2015 String runString = null; | |
2016 try { | |
2017 // (0) == 0 | |
2018 runString = "(0)"; | |
2019 if (0 != jtt.bytecode.BC_anewarray.test(0)) { | |
2020 fail(runString); | |
2021 return; | |
2022 } | |
2023 // (1) == 1 | |
2024 runString = "(1)"; | |
2025 if (1 != jtt.bytecode.BC_anewarray.test(1)) { | |
2026 fail(runString); | |
2027 return; | |
2028 } | |
2029 } catch (Throwable t) { | |
2030 fail(runString, t); | |
2031 return; | |
2032 } | |
2033 pass(); | |
2034 } | |
2035 | |
2036 static void jtt_bytecode_BC_areturn() { | |
2037 begin("jtt.bytecode.BC_areturn"); | |
2038 String runString = null; | |
2039 try { | |
2040 // (null) == null | |
2041 runString = "(null)"; | |
2042 if (null != jtt.bytecode.BC_areturn.test(null)) { | |
2043 fail(runString); | |
2044 return; | |
2045 } | |
2046 // ("") == "" | |
2047 runString = "(\"\")"; | |
2048 if (!"".equals(jtt.bytecode.BC_areturn.test(""))) { | |
2049 fail(runString); | |
2050 return; | |
2051 } | |
2052 // ("this") == "this" | |
2053 runString = "(\"this\")"; | |
2054 if (!"this".equals(jtt.bytecode.BC_areturn.test("this"))) { | |
2055 fail(runString); | |
2056 return; | |
2057 } | |
2058 } catch (Throwable t) { | |
2059 fail(runString, t); | |
2060 return; | |
2061 } | |
2062 pass(); | |
2063 } | |
2064 | |
2065 static void jtt_bytecode_BC_arraylength() { | |
2066 begin("jtt.bytecode.BC_arraylength"); | |
2067 String runString = null; | |
2068 try { | |
2069 // (1) == 3 | |
2070 runString = "(1)"; | |
2071 if (3 != jtt.bytecode.BC_arraylength.test(1)) { | |
2072 fail(runString); | |
2073 return; | |
2074 } | |
2075 // (2) == 4 | |
2076 runString = "(2)"; | |
2077 if (4 != jtt.bytecode.BC_arraylength.test(2)) { | |
2078 fail(runString); | |
2079 return; | |
2080 } | |
2081 // (3) == 5 | |
2082 runString = "(3)"; | |
2083 if (5 != jtt.bytecode.BC_arraylength.test(3)) { | |
2084 fail(runString); | |
2085 return; | |
2086 } | |
2087 // (4) == 5 | |
2088 runString = "(4)"; | |
2089 if (5 != jtt.bytecode.BC_arraylength.test(4)) { | |
2090 fail(runString); | |
2091 return; | |
2092 } | |
2093 // (5) == 42 | |
2094 runString = "(5)"; | |
2095 if (42 != jtt.bytecode.BC_arraylength.test(5)) { | |
2096 fail(runString); | |
2097 return; | |
2098 } | |
2099 } catch (Throwable t) { | |
2100 fail(runString, t); | |
2101 return; | |
2102 } | |
2103 pass(); | |
2104 } | |
2105 | |
2106 static void jtt_bytecode_BC_athrow() { | |
2107 begin("jtt.bytecode.BC_athrow"); | |
2108 String runString = null; | |
2109 try { | |
2110 // (0) == 0 | |
2111 runString = "(0)"; | |
2112 if (0 != jtt.bytecode.BC_athrow.test(0)) { | |
2113 fail(runString); | |
2114 return; | |
2115 } | |
2116 // (1) == 1 | |
2117 runString = "(1)"; | |
2118 if (1 != jtt.bytecode.BC_athrow.test(1)) { | |
2119 fail(runString); | |
2120 return; | |
2121 } | |
2122 // (2) == !java.lang.Throwable | |
2123 try { | |
2124 runString = "(2)"; | |
2125 jtt.bytecode.BC_athrow.test(2); | |
2126 fail(runString); | |
2127 return; | |
2128 } catch (Throwable e) { | |
2129 if (e.getClass() != java.lang.Throwable.class) { | |
2130 fail(runString, e); | |
2131 return; | |
2132 } | |
2133 } | |
2134 // (3) == 3 | |
2135 runString = "(3)"; | |
2136 if (3 != jtt.bytecode.BC_athrow.test(3)) { | |
2137 fail(runString); | |
2138 return; | |
2139 } | |
2140 } catch (Throwable t) { | |
2141 fail(runString, t); | |
2142 return; | |
2143 } | |
2144 pass(); | |
2145 } | |
2146 | |
2147 static void jtt_bytecode_BC_baload() { | |
2148 begin("jtt.bytecode.BC_baload"); | |
2149 String runString = null; | |
2150 try { | |
2151 // (0) == true | |
2152 runString = "(0)"; | |
2153 if (true != jtt.bytecode.BC_baload.test(0)) { | |
2154 fail(runString); | |
2155 return; | |
2156 } | |
2157 // (1) == false | |
2158 runString = "(1)"; | |
2159 if (false != jtt.bytecode.BC_baload.test(1)) { | |
2160 fail(runString); | |
2161 return; | |
2162 } | |
2163 // (2) == true | |
2164 runString = "(2)"; | |
2165 if (true != jtt.bytecode.BC_baload.test(2)) { | |
2166 fail(runString); | |
2167 return; | |
2168 } | |
2169 // (3) == false | |
2170 runString = "(3)"; | |
2171 if (false != jtt.bytecode.BC_baload.test(3)) { | |
2172 fail(runString); | |
2173 return; | |
2174 } | |
2175 } catch (Throwable t) { | |
2176 fail(runString, t); | |
2177 return; | |
2178 } | |
2179 pass(); | |
2180 } | |
2181 | |
2182 static void jtt_bytecode_BC_bastore() { | |
2183 begin("jtt.bytecode.BC_bastore"); | |
2184 String runString = null; | |
2185 try { | |
2186 // (0,true) == true | |
2187 runString = "(0,true)"; | |
2188 if (true != jtt.bytecode.BC_bastore.test(0, true)) { | |
2189 fail(runString); | |
2190 return; | |
2191 } | |
2192 // (1,false) == false | |
2193 runString = "(1,false)"; | |
2194 if (false != jtt.bytecode.BC_bastore.test(1, false)) { | |
2195 fail(runString); | |
2196 return; | |
2197 } | |
2198 // (2,true) == true | |
2199 runString = "(2,true)"; | |
2200 if (true != jtt.bytecode.BC_bastore.test(2, true)) { | |
2201 fail(runString); | |
2202 return; | |
2203 } | |
2204 // (3,false) == false | |
2205 runString = "(3,false)"; | |
2206 if (false != jtt.bytecode.BC_bastore.test(3, false)) { | |
2207 fail(runString); | |
2208 return; | |
2209 } | |
2210 } catch (Throwable t) { | |
2211 fail(runString, t); | |
2212 return; | |
2213 } | |
2214 pass(); | |
2215 } | |
2216 | |
2217 static void jtt_bytecode_BC_caload() { | |
2218 begin("jtt.bytecode.BC_caload"); | |
2219 String runString = null; | |
2220 try { | |
2221 // (0) == '\0' | |
2222 runString = "(0)"; | |
2223 if ((char) 0 != jtt.bytecode.BC_caload.test(0)) { | |
2224 fail(runString); | |
2225 return; | |
2226 } | |
2227 // (1) == 'a' | |
2228 runString = "(1)"; | |
2229 if ((char) 97 != jtt.bytecode.BC_caload.test(1)) { | |
2230 fail(runString); | |
2231 return; | |
2232 } | |
2233 // (2) == ' ' | |
2234 runString = "(2)"; | |
2235 if ((char) 32 != jtt.bytecode.BC_caload.test(2)) { | |
2236 fail(runString); | |
2237 return; | |
2238 } | |
2239 // (3) == '\23420' | |
2240 runString = "(3)"; | |
2241 if ((char) 10000 != jtt.bytecode.BC_caload.test(3)) { | |
2242 fail(runString); | |
2243 return; | |
2244 } | |
2245 } catch (Throwable t) { | |
2246 fail(runString, t); | |
2247 return; | |
2248 } | |
2249 pass(); | |
2250 } | |
2251 | |
2252 static void jtt_bytecode_BC_castore() { | |
2253 begin("jtt.bytecode.BC_castore"); | |
2254 String runString = null; | |
2255 try { | |
2256 // (0,'a') == 'a' | |
2257 runString = "(0,'a')"; | |
2258 if ((char) 97 != jtt.bytecode.BC_castore.test(0, (char) 97)) { | |
2259 fail(runString); | |
2260 return; | |
2261 } | |
2262 // (1,'A') == 'A' | |
2263 runString = "(1,'A')"; | |
2264 if ((char) 65 != jtt.bytecode.BC_castore.test(1, (char) 65)) { | |
2265 fail(runString); | |
2266 return; | |
2267 } | |
2268 // (2,'*') == '*' | |
2269 runString = "(2,'*')"; | |
2270 if ((char) 42 != jtt.bytecode.BC_castore.test(2, (char) 42)) { | |
2271 fail(runString); | |
2272 return; | |
2273 } | |
2274 // (3,'x') == 'x' | |
2275 runString = "(3,'x')"; | |
2276 if ((char) 120 != jtt.bytecode.BC_castore.test(3, (char) 120)) { | |
2277 fail(runString); | |
2278 return; | |
2279 } | |
2280 } catch (Throwable t) { | |
2281 fail(runString, t); | |
2282 return; | |
2283 } | |
2284 pass(); | |
2285 } | |
2286 | |
2287 static void jtt_bytecode_BC_checkcast01() { | |
2288 begin("jtt.bytecode.BC_checkcast01"); | |
2289 String runString = null; | |
2290 try { | |
2291 // (0) == -1 | |
2292 runString = "(0)"; | |
2293 if (-1 != jtt.bytecode.BC_checkcast01.test(0)) { | |
2294 fail(runString); | |
2295 return; | |
2296 } | |
2297 // (1) == -1 | |
2298 runString = "(1)"; | |
2299 if (-1 != jtt.bytecode.BC_checkcast01.test(1)) { | |
2300 fail(runString); | |
2301 return; | |
2302 } | |
2303 // (4) == 4 | |
2304 runString = "(4)"; | |
2305 if (4 != jtt.bytecode.BC_checkcast01.test(4)) { | |
2306 fail(runString); | |
2307 return; | |
2308 } | |
2309 } catch (Throwable t) { | |
2310 fail(runString, t); | |
2311 return; | |
2312 } | |
2313 pass(); | |
2314 } | |
2315 | |
2316 static void jtt_bytecode_BC_checkcast02() { | |
2317 begin("jtt.bytecode.BC_checkcast02"); | |
2318 String runString = null; | |
2319 try { | |
2320 // (0) == -1 | |
2321 runString = "(0)"; | |
2322 if (-1 != jtt.bytecode.BC_checkcast02.test(0)) { | |
2323 fail(runString); | |
2324 return; | |
2325 } | |
2326 // (1) == -1 | |
2327 runString = "(1)"; | |
2328 if (-1 != jtt.bytecode.BC_checkcast02.test(1)) { | |
2329 fail(runString); | |
2330 return; | |
2331 } | |
2332 // (2) == -1 | |
2333 runString = "(2)"; | |
2334 if (-1 != jtt.bytecode.BC_checkcast02.test(2)) { | |
2335 fail(runString); | |
2336 return; | |
2337 } | |
2338 // (3) == -1 | |
2339 runString = "(3)"; | |
2340 if (-1 != jtt.bytecode.BC_checkcast02.test(3)) { | |
2341 fail(runString); | |
2342 return; | |
2343 } | |
2344 } catch (Throwable t) { | |
2345 fail(runString, t); | |
2346 return; | |
2347 } | |
2348 pass(); | |
2349 } | |
2350 | |
2351 static void jtt_bytecode_BC_d2f() { | |
2352 begin("jtt.bytecode.BC_d2f"); | |
2353 String runString = null; | |
2354 try { | |
2355 // (0.0) == 0.0 | |
2356 runString = "(0.0)"; | |
2357 if (0.0f != jtt.bytecode.BC_d2f.test(0.0)) { | |
2358 fail(runString); | |
2359 return; | |
2360 } | |
2361 // (1.0) == 1.0 | |
2362 runString = "(1.0)"; | |
2363 if (1.0f != jtt.bytecode.BC_d2f.test(1.0)) { | |
2364 fail(runString); | |
2365 return; | |
2366 } | |
2367 // (-1.06) == -1.06 | |
2368 runString = "(-1.06)"; | |
2369 if (-1.06f != jtt.bytecode.BC_d2f.test(-1.06)) { | |
2370 fail(runString); | |
2371 return; | |
2372 } | |
2373 } catch (Throwable t) { | |
2374 fail(runString, t); | |
2375 return; | |
2376 } | |
2377 pass(); | |
2378 } | |
2379 | |
2380 static void jtt_bytecode_BC_d2i01() { | |
2381 begin("jtt.bytecode.BC_d2i01"); | |
2382 String runString = null; | |
2383 try { | |
2384 // (0.0) == 0 | |
2385 runString = "(0.0)"; | |
2386 if (0 != jtt.bytecode.BC_d2i01.test(0.0)) { | |
2387 fail(runString); | |
2388 return; | |
2389 } | |
2390 // (1.0) == 1 | |
2391 runString = "(1.0)"; | |
2392 if (1 != jtt.bytecode.BC_d2i01.test(1.0)) { | |
2393 fail(runString); | |
2394 return; | |
2395 } | |
2396 // (-1.06) == -1 | |
2397 runString = "(-1.06)"; | |
2398 if (-1 != jtt.bytecode.BC_d2i01.test(-1.06)) { | |
2399 fail(runString); | |
2400 return; | |
2401 } | |
2402 // (-156.82743) == -156 | |
2403 runString = "(-156.82743)"; | |
2404 if (-156 != jtt.bytecode.BC_d2i01.test(-156.82743)) { | |
2405 fail(runString); | |
2406 return; | |
2407 } | |
2408 } catch (Throwable t) { | |
2409 fail(runString, t); | |
2410 return; | |
2411 } | |
2412 pass(); | |
2413 } | |
2414 | |
2415 static void jtt_bytecode_BC_d2i02() { | |
2416 begin("jtt.bytecode.BC_d2i02"); | |
2417 String runString = null; | |
2418 try { | |
2419 // (0) == -2147483648 | |
2420 runString = "(0)"; | |
2421 if (-2147483648 != jtt.bytecode.BC_d2i02.test(0)) { | |
2422 fail(runString); | |
2423 return; | |
2424 } | |
2425 } catch (Throwable t) { | |
2426 fail(runString, t); | |
2427 return; | |
2428 } | |
2429 pass(); | |
2430 } | |
2431 | |
2432 static void jtt_bytecode_BC_d2l01() { | |
2433 begin("jtt.bytecode.BC_d2l01"); | |
2434 String runString = null; | |
2435 try { | |
2436 // (0.0) == 0 | |
2437 runString = "(0.0)"; | |
2438 if (0L != jtt.bytecode.BC_d2l01.test(0.0)) { | |
2439 fail(runString); | |
2440 return; | |
2441 } | |
2442 // (1.0) == 1 | |
2443 runString = "(1.0)"; | |
2444 if (1L != jtt.bytecode.BC_d2l01.test(1.0)) { | |
2445 fail(runString); | |
2446 return; | |
2447 } | |
2448 // (-1.06) == -1 | |
2449 runString = "(-1.06)"; | |
2450 if (-1L != jtt.bytecode.BC_d2l01.test(-1.06)) { | |
2451 fail(runString); | |
2452 return; | |
2453 } | |
2454 // (-156.82743) == -156 | |
2455 runString = "(-156.82743)"; | |
2456 if (-156L != jtt.bytecode.BC_d2l01.test(-156.82743)) { | |
2457 fail(runString); | |
2458 return; | |
2459 } | |
2460 } catch (Throwable t) { | |
2461 fail(runString, t); | |
2462 return; | |
2463 } | |
2464 pass(); | |
2465 } | |
2466 | |
2467 static void jtt_bytecode_BC_d2l02() { | |
2468 begin("jtt.bytecode.BC_d2l02"); | |
2469 String runString = null; | |
2470 try { | |
2471 // (0) == -9223372036854775808 | |
2472 runString = "(0)"; | |
2473 if (-9223372036854775808L != jtt.bytecode.BC_d2l02.test(0)) { | |
2474 fail(runString); | |
2475 return; | |
2476 } | |
2477 } catch (Throwable t) { | |
2478 fail(runString, t); | |
2479 return; | |
2480 } | |
2481 pass(); | |
2482 } | |
2483 | |
2484 static void jtt_bytecode_BC_dadd() { | |
2485 begin("jtt.bytecode.BC_dadd"); | |
2486 String runString = null; | |
2487 try { | |
2488 // (0.0,0.0) == 0.0 | |
2489 runString = "(0.0,0.0)"; | |
2490 if (0.0 != jtt.bytecode.BC_dadd.test(0.0, 0.0)) { | |
2491 fail(runString); | |
2492 return; | |
2493 } | |
2494 // (1.0,1.0) == 2.0 | |
2495 runString = "(1.0,1.0)"; | |
2496 if (2.0 != jtt.bytecode.BC_dadd.test(1.0, 1.0)) { | |
2497 fail(runString); | |
2498 return; | |
2499 } | |
2500 // (253.11,54.43) == 307.54 | |
2501 runString = "(253.11,54.43)"; | |
2502 if (307.54 != jtt.bytecode.BC_dadd.test(253.11, 54.43)) { | |
2503 fail(runString); | |
2504 return; | |
2505 } | |
2506 } catch (Throwable t) { | |
2507 fail(runString, t); | |
2508 return; | |
2509 } | |
2510 pass(); | |
2511 } | |
2512 | |
2513 static void jtt_bytecode_BC_daload() { | |
2514 begin("jtt.bytecode.BC_daload"); | |
2515 String runString = null; | |
2516 try { | |
2517 // (0) == 0.0 | |
2518 runString = "(0)"; | |
2519 if (0.0 != jtt.bytecode.BC_daload.test(0)) { | |
2520 fail(runString); | |
2521 return; | |
2522 } | |
2523 // (1) == -1.1 | |
2524 runString = "(1)"; | |
2525 if (-1.1 != jtt.bytecode.BC_daload.test(1)) { | |
2526 fail(runString); | |
2527 return; | |
2528 } | |
2529 // (2) == 4.32 | |
2530 runString = "(2)"; | |
2531 if (4.32 != jtt.bytecode.BC_daload.test(2)) { | |
2532 fail(runString); | |
2533 return; | |
2534 } | |
2535 // (3) == 6.06 | |
2536 runString = "(3)"; | |
2537 if (6.06 != jtt.bytecode.BC_daload.test(3)) { | |
2538 fail(runString); | |
2539 return; | |
2540 } | |
2541 } catch (Throwable t) { | |
2542 fail(runString, t); | |
2543 return; | |
2544 } | |
2545 pass(); | |
2546 } | |
2547 | |
2548 static void jtt_bytecode_BC_dastore() { | |
2549 begin("jtt.bytecode.BC_dastore"); | |
2550 String runString = null; | |
2551 try { | |
2552 // (0,0.01) == 0.01 | |
2553 runString = "(0,0.01)"; | |
2554 if (0.01 != jtt.bytecode.BC_dastore.test(0, 0.01)) { | |
2555 fail(runString); | |
2556 return; | |
2557 } | |
2558 // (1,-1.4) == -1.4 | |
2559 runString = "(1,-1.4)"; | |
2560 if (-1.4 != jtt.bytecode.BC_dastore.test(1, -1.4)) { | |
2561 fail(runString); | |
2562 return; | |
2563 } | |
2564 // (2,0.01) == 0.01 | |
2565 runString = "(2,0.01)"; | |
2566 if (0.01 != jtt.bytecode.BC_dastore.test(2, 0.01)) { | |
2567 fail(runString); | |
2568 return; | |
2569 } | |
2570 // (3,-1.4) == -1.4 | |
2571 runString = "(3,-1.4)"; | |
2572 if (-1.4 != jtt.bytecode.BC_dastore.test(3, -1.4)) { | |
2573 fail(runString); | |
2574 return; | |
2575 } | |
2576 } catch (Throwable t) { | |
2577 fail(runString, t); | |
2578 return; | |
2579 } | |
2580 pass(); | |
2581 } | |
2582 | |
2583 static void jtt_bytecode_BC_dcmp01() { | |
2584 begin("jtt.bytecode.BC_dcmp01"); | |
2585 String runString = null; | |
2586 try { | |
2587 // (0.0,-0.1) == false | |
2588 runString = "(0.0,-0.1)"; | |
2589 if (false != jtt.bytecode.BC_dcmp01.test(0.0, -0.1)) { | |
2590 fail(runString); | |
2591 return; | |
2592 } | |
2593 // (78.0,78.001) == true | |
2594 runString = "(78.0,78.001)"; | |
2595 if (true != jtt.bytecode.BC_dcmp01.test(78.0, 78.001)) { | |
2596 fail(runString); | |
2597 return; | |
2598 } | |
2599 } catch (Throwable t) { | |
2600 fail(runString, t); | |
2601 return; | |
2602 } | |
2603 pass(); | |
2604 } | |
2605 | |
2606 static void jtt_bytecode_BC_dcmp02() { | |
2607 begin("jtt.bytecode.BC_dcmp02"); | |
2608 String runString = null; | |
2609 try { | |
2610 // (-1.0) == false | |
2611 runString = "(-1.0)"; | |
2612 if (false != jtt.bytecode.BC_dcmp02.test(-1.0)) { | |
2613 fail(runString); | |
2614 return; | |
2615 } | |
2616 // (1.0) == false | |
2617 runString = "(1.0)"; | |
2618 if (false != jtt.bytecode.BC_dcmp02.test(1.0)) { | |
2619 fail(runString); | |
2620 return; | |
2621 } | |
2622 // (0.0) == false | |
2623 runString = "(0.0)"; | |
2624 if (false != jtt.bytecode.BC_dcmp02.test(0.0)) { | |
2625 fail(runString); | |
2626 return; | |
2627 } | |
2628 // (-0.0) == false | |
2629 runString = "(-0.0)"; | |
2630 if (false != jtt.bytecode.BC_dcmp02.test(-0.0)) { | |
2631 fail(runString); | |
2632 return; | |
2633 } | |
2634 } catch (Throwable t) { | |
2635 fail(runString, t); | |
2636 return; | |
2637 } | |
2638 pass(); | |
2639 } | |
2640 | |
2641 static void jtt_bytecode_BC_dcmp03() { | |
2642 begin("jtt.bytecode.BC_dcmp03"); | |
2643 String runString = null; | |
2644 try { | |
2645 // (-1.0) == true | |
2646 runString = "(-1.0)"; | |
2647 if (true != jtt.bytecode.BC_dcmp03.test(-1.0)) { | |
2648 fail(runString); | |
2649 return; | |
2650 } | |
2651 // (1.0) == true | |
2652 runString = "(1.0)"; | |
2653 if (true != jtt.bytecode.BC_dcmp03.test(1.0)) { | |
2654 fail(runString); | |
2655 return; | |
2656 } | |
2657 // (0.0) == false | |
2658 runString = "(0.0)"; | |
2659 if (false != jtt.bytecode.BC_dcmp03.test(0.0)) { | |
2660 fail(runString); | |
2661 return; | |
2662 } | |
2663 // (-0.0) == false | |
2664 runString = "(-0.0)"; | |
2665 if (false != jtt.bytecode.BC_dcmp03.test(-0.0)) { | |
2666 fail(runString); | |
2667 return; | |
2668 } | |
2669 } catch (Throwable t) { | |
2670 fail(runString, t); | |
2671 return; | |
2672 } | |
2673 pass(); | |
2674 } | |
2675 | |
2676 static void jtt_bytecode_BC_dcmp04() { | |
2677 begin("jtt.bytecode.BC_dcmp04"); | |
2678 String runString = null; | |
2679 try { | |
2680 // (-1.0) == false | |
2681 runString = "(-1.0)"; | |
2682 if (false != jtt.bytecode.BC_dcmp04.test(-1.0)) { | |
2683 fail(runString); | |
2684 return; | |
2685 } | |
2686 // (1.0) == false | |
2687 runString = "(1.0)"; | |
2688 if (false != jtt.bytecode.BC_dcmp04.test(1.0)) { | |
2689 fail(runString); | |
2690 return; | |
2691 } | |
2692 // (0.0) == false | |
2693 runString = "(0.0)"; | |
2694 if (false != jtt.bytecode.BC_dcmp04.test(0.0)) { | |
2695 fail(runString); | |
2696 return; | |
2697 } | |
2698 // (-0.0) == false | |
2699 runString = "(-0.0)"; | |
2700 if (false != jtt.bytecode.BC_dcmp04.test(-0.0)) { | |
2701 fail(runString); | |
2702 return; | |
2703 } | |
2704 } catch (Throwable t) { | |
2705 fail(runString, t); | |
2706 return; | |
2707 } | |
2708 pass(); | |
2709 } | |
2710 | |
2711 static void jtt_bytecode_BC_dcmp05() { | |
2712 begin("jtt.bytecode.BC_dcmp05"); | |
2713 String runString = null; | |
2714 try { | |
2715 // (-1.0) == true | |
2716 runString = "(-1.0)"; | |
2717 if (true != jtt.bytecode.BC_dcmp05.test(-1.0)) { | |
2718 fail(runString); | |
2719 return; | |
2720 } | |
2721 // (1.0) == true | |
2722 runString = "(1.0)"; | |
2723 if (true != jtt.bytecode.BC_dcmp05.test(1.0)) { | |
2724 fail(runString); | |
2725 return; | |
2726 } | |
2727 // (0.0) == false | |
2728 runString = "(0.0)"; | |
2729 if (false != jtt.bytecode.BC_dcmp05.test(0.0)) { | |
2730 fail(runString); | |
2731 return; | |
2732 } | |
2733 } catch (Throwable t) { | |
2734 fail(runString, t); | |
2735 return; | |
2736 } | |
2737 pass(); | |
2738 } | |
2739 | |
2740 static void jtt_bytecode_BC_dcmp06() { | |
2741 begin("jtt.bytecode.BC_dcmp06"); | |
2742 String runString = null; | |
2743 try { | |
2744 // (-1.0) == true | |
2745 runString = "(-1.0)"; | |
2746 if (true != jtt.bytecode.BC_dcmp06.test(-1.0)) { | |
2747 fail(runString); | |
2748 return; | |
2749 } | |
2750 // (1.0) == true | |
2751 runString = "(1.0)"; | |
2752 if (true != jtt.bytecode.BC_dcmp06.test(1.0)) { | |
2753 fail(runString); | |
2754 return; | |
2755 } | |
2756 // (0.0) == false | |
2757 runString = "(0.0)"; | |
2758 if (false != jtt.bytecode.BC_dcmp06.test(0.0)) { | |
2759 fail(runString); | |
2760 return; | |
2761 } | |
2762 } catch (Throwable t) { | |
2763 fail(runString, t); | |
2764 return; | |
2765 } | |
2766 pass(); | |
2767 } | |
2768 | |
2769 static void jtt_bytecode_BC_dcmp07() { | |
2770 begin("jtt.bytecode.BC_dcmp07"); | |
2771 String runString = null; | |
2772 try { | |
2773 // (-1.0) == false | |
2774 runString = "(-1.0)"; | |
2775 if (false != jtt.bytecode.BC_dcmp07.test(-1.0)) { | |
2776 fail(runString); | |
2777 return; | |
2778 } | |
2779 // (1.0) == false | |
2780 runString = "(1.0)"; | |
2781 if (false != jtt.bytecode.BC_dcmp07.test(1.0)) { | |
2782 fail(runString); | |
2783 return; | |
2784 } | |
2785 // (0.0) == false | |
2786 runString = "(0.0)"; | |
2787 if (false != jtt.bytecode.BC_dcmp07.test(0.0)) { | |
2788 fail(runString); | |
2789 return; | |
2790 } | |
2791 } catch (Throwable t) { | |
2792 fail(runString, t); | |
2793 return; | |
2794 } | |
2795 pass(); | |
2796 } | |
2797 | |
2798 static void jtt_bytecode_BC_dcmp08() { | |
2799 begin("jtt.bytecode.BC_dcmp08"); | |
2800 String runString = null; | |
2801 try { | |
2802 // (-1.0) == true | |
2803 runString = "(-1.0)"; | |
2804 if (true != jtt.bytecode.BC_dcmp08.test(-1.0)) { | |
2805 fail(runString); | |
2806 return; | |
2807 } | |
2808 // (1.0) == true | |
2809 runString = "(1.0)"; | |
2810 if (true != jtt.bytecode.BC_dcmp08.test(1.0)) { | |
2811 fail(runString); | |
2812 return; | |
2813 } | |
2814 // (0.0) == false | |
2815 runString = "(0.0)"; | |
2816 if (false != jtt.bytecode.BC_dcmp08.test(0.0)) { | |
2817 fail(runString); | |
2818 return; | |
2819 } | |
2820 } catch (Throwable t) { | |
2821 fail(runString, t); | |
2822 return; | |
2823 } | |
2824 pass(); | |
2825 } | |
2826 | |
2827 static void jtt_bytecode_BC_dcmp09() { | |
2828 begin("jtt.bytecode.BC_dcmp09"); | |
2829 String runString = null; | |
2830 try { | |
2831 // (-1.0) == false | |
2832 runString = "(-1.0)"; | |
2833 if (false != jtt.bytecode.BC_dcmp09.test(-1.0)) { | |
2834 fail(runString); | |
2835 return; | |
2836 } | |
2837 // (1.0) == false | |
2838 runString = "(1.0)"; | |
2839 if (false != jtt.bytecode.BC_dcmp09.test(1.0)) { | |
2840 fail(runString); | |
2841 return; | |
2842 } | |
2843 // (0.0) == false | |
2844 runString = "(0.0)"; | |
2845 if (false != jtt.bytecode.BC_dcmp09.test(0.0)) { | |
2846 fail(runString); | |
2847 return; | |
2848 } | |
2849 } catch (Throwable t) { | |
2850 fail(runString, t); | |
2851 return; | |
2852 } | |
2853 pass(); | |
2854 } | |
2855 | |
2856 static void jtt_bytecode_BC_dcmp10() { | |
2857 begin("jtt.bytecode.BC_dcmp10"); | |
2858 String runString = null; | |
2859 try { | |
2860 // (0) == false | |
2861 runString = "(0)"; | |
2862 if (false != jtt.bytecode.BC_dcmp10.test(0)) { | |
2863 fail(runString); | |
2864 return; | |
2865 } | |
2866 // (1) == true | |
2867 runString = "(1)"; | |
2868 if (true != jtt.bytecode.BC_dcmp10.test(1)) { | |
2869 fail(runString); | |
2870 return; | |
2871 } | |
2872 // (2) == true | |
2873 runString = "(2)"; | |
2874 if (true != jtt.bytecode.BC_dcmp10.test(2)) { | |
2875 fail(runString); | |
2876 return; | |
2877 } | |
2878 // (3) == false | |
2879 runString = "(3)"; | |
2880 if (false != jtt.bytecode.BC_dcmp10.test(3)) { | |
2881 fail(runString); | |
2882 return; | |
2883 } | |
2884 // (4) == true | |
2885 runString = "(4)"; | |
2886 if (true != jtt.bytecode.BC_dcmp10.test(4)) { | |
2887 fail(runString); | |
2888 return; | |
2889 } | |
2890 // (5) == true | |
2891 runString = "(5)"; | |
2892 if (true != jtt.bytecode.BC_dcmp10.test(5)) { | |
2893 fail(runString); | |
2894 return; | |
2895 } | |
2896 // (6) == false | |
2897 runString = "(6)"; | |
2898 if (false != jtt.bytecode.BC_dcmp10.test(6)) { | |
2899 fail(runString); | |
2900 return; | |
2901 } | |
2902 // (7) == false | |
2903 runString = "(7)"; | |
2904 if (false != jtt.bytecode.BC_dcmp10.test(7)) { | |
2905 fail(runString); | |
2906 return; | |
2907 } | |
2908 // (8) == false | |
2909 runString = "(8)"; | |
2910 if (false != jtt.bytecode.BC_dcmp10.test(8)) { | |
2911 fail(runString); | |
2912 return; | |
2913 } | |
2914 } catch (Throwable t) { | |
2915 fail(runString, t); | |
2916 return; | |
2917 } | |
2918 pass(); | |
2919 } | |
2920 | |
2921 static void jtt_bytecode_BC_ddiv() { | |
2922 begin("jtt.bytecode.BC_ddiv"); | |
2923 String runString = null; | |
2924 try { | |
2925 // (311.0,10.0) == 31.1 | |
2926 runString = "(311.0,10.0)"; | |
2927 if (31.1 != jtt.bytecode.BC_ddiv.test(311.0, 10.0)) { | |
2928 fail(runString); | |
2929 return; | |
2930 } | |
2931 } catch (Throwable t) { | |
2932 fail(runString, t); | |
2933 return; | |
2934 } | |
2935 pass(); | |
2936 } | |
2937 | |
2938 static void jtt_bytecode_BC_dmul() { | |
2939 begin("jtt.bytecode.BC_dmul"); | |
2940 String runString = null; | |
2941 try { | |
2942 // (311.0,10.0) == 3110.0 | |
2943 runString = "(311.0,10.0)"; | |
2944 if (3110.0 != jtt.bytecode.BC_dmul.test(311.0, 10.0)) { | |
2945 fail(runString); | |
2946 return; | |
2947 } | |
2948 } catch (Throwable t) { | |
2949 fail(runString, t); | |
2950 return; | |
2951 } | |
2952 pass(); | |
2953 } | |
2954 | |
2955 static void jtt_bytecode_BC_dneg() { | |
2956 begin("jtt.bytecode.BC_dneg"); | |
2957 String runString = null; | |
2958 try { | |
2959 // (0.0) == -0.0 | |
2960 runString = "(0.0)"; | |
2961 if (-0.0 != jtt.bytecode.BC_dneg.test(0.0)) { | |
2962 fail(runString); | |
2963 return; | |
2964 } | |
2965 // (-1.01) == 1.01 | |
2966 runString = "(-1.01)"; | |
2967 if (1.01 != jtt.bytecode.BC_dneg.test(-1.01)) { | |
2968 fail(runString); | |
2969 return; | |
2970 } | |
2971 // (7263.8734) == -7263.8734 | |
2972 runString = "(7263.8734)"; | |
2973 if (-7263.8734 != jtt.bytecode.BC_dneg.test(7263.8734)) { | |
2974 fail(runString); | |
2975 return; | |
2976 } | |
2977 } catch (Throwable t) { | |
2978 fail(runString, t); | |
2979 return; | |
2980 } | |
2981 pass(); | |
2982 } | |
2983 | |
2984 static void jtt_bytecode_BC_drem() { | |
2985 begin("jtt.bytecode.BC_drem"); | |
2986 String runString = null; | |
2987 try { | |
2988 // (311.0,10.0) == 1.0 | |
2989 runString = "(311.0,10.0)"; | |
2990 if (1.0 != jtt.bytecode.BC_drem.test(311.0, 10.0)) { | |
2991 fail(runString); | |
2992 return; | |
2993 } | |
2994 } catch (Throwable t) { | |
2995 fail(runString, t); | |
2996 return; | |
2997 } | |
2998 pass(); | |
2999 } | |
3000 | |
3001 static void jtt_bytecode_BC_dreturn() { | |
3002 begin("jtt.bytecode.BC_dreturn"); | |
3003 String runString = null; | |
3004 try { | |
3005 // (0.0) == 0.0 | |
3006 runString = "(0.0)"; | |
3007 if (0.0 != jtt.bytecode.BC_dreturn.test(0.0)) { | |
3008 fail(runString); | |
3009 return; | |
3010 } | |
3011 // (1.1) == 1.1 | |
3012 runString = "(1.1)"; | |
3013 if (1.1 != jtt.bytecode.BC_dreturn.test(1.1)) { | |
3014 fail(runString); | |
3015 return; | |
3016 } | |
3017 // (-1.4) == -1.4 | |
3018 runString = "(-1.4)"; | |
3019 if (-1.4 != jtt.bytecode.BC_dreturn.test(-1.4)) { | |
3020 fail(runString); | |
3021 return; | |
3022 } | |
3023 // (256.33) == 256.33 | |
3024 runString = "(256.33)"; | |
3025 if (256.33 != jtt.bytecode.BC_dreturn.test(256.33)) { | |
3026 fail(runString); | |
3027 return; | |
3028 } | |
3029 // (1000.001) == 1000.001 | |
3030 runString = "(1000.001)"; | |
3031 if (1000.001 != jtt.bytecode.BC_dreturn.test(1000.001)) { | |
3032 fail(runString); | |
3033 return; | |
3034 } | |
3035 } catch (Throwable t) { | |
3036 fail(runString, t); | |
3037 return; | |
3038 } | |
3039 pass(); | |
3040 } | |
3041 | |
3042 static void jtt_bytecode_BC_dsub() { | |
3043 begin("jtt.bytecode.BC_dsub"); | |
3044 String runString = null; | |
3045 try { | |
3046 // (0.0,0.0) == 0.0 | |
3047 runString = "(0.0,0.0)"; | |
3048 if (0.0 != jtt.bytecode.BC_dsub.test(0.0, 0.0)) { | |
3049 fail(runString); | |
3050 return; | |
3051 } | |
3052 // (1.0,1.0) == 0.0 | |
3053 runString = "(1.0,1.0)"; | |
3054 if (0.0 != jtt.bytecode.BC_dsub.test(1.0, 1.0)) { | |
3055 fail(runString); | |
3056 return; | |
3057 } | |
3058 // (253.11,54.43) == 198.68 | |
3059 runString = "(253.11,54.43)"; | |
3060 if (198.68 != jtt.bytecode.BC_dsub.test(253.11, 54.43)) { | |
3061 fail(runString); | |
3062 return; | |
3063 } | |
3064 } catch (Throwable t) { | |
3065 fail(runString, t); | |
3066 return; | |
3067 } | |
3068 pass(); | |
3069 } | |
3070 | |
3071 static void jtt_bytecode_BC_f2d() { | |
3072 begin("jtt.bytecode.BC_f2d"); | |
3073 String runString = null; | |
3074 try { | |
3075 // (0.0) == 0.0 | |
3076 runString = "(0.0)"; | |
3077 if (0.0 != jtt.bytecode.BC_f2d.test(0.0f)) { | |
3078 fail(runString); | |
3079 return; | |
3080 } | |
3081 // (1.0) == 1.0 | |
3082 runString = "(1.0)"; | |
3083 if (1.0 != jtt.bytecode.BC_f2d.test(1.0f)) { | |
3084 fail(runString); | |
3085 return; | |
3086 } | |
3087 // (-2.0) == -2.0 | |
3088 runString = "(-2.0)"; | |
3089 if (-2.0 != jtt.bytecode.BC_f2d.test(-2.0f)) { | |
3090 fail(runString); | |
3091 return; | |
3092 } | |
3093 } catch (Throwable t) { | |
3094 fail(runString, t); | |
3095 return; | |
3096 } | |
3097 pass(); | |
3098 } | |
3099 | |
3100 static void jtt_bytecode_BC_f2i01() { | |
3101 begin("jtt.bytecode.BC_f2i01"); | |
3102 String runString = null; | |
3103 try { | |
3104 // (0.0) == 0 | |
3105 runString = "(0.0)"; | |
3106 if (0 != jtt.bytecode.BC_f2i01.test(0.0f)) { | |
3107 fail(runString); | |
3108 return; | |
3109 } | |
3110 // (1.0) == 1 | |
3111 runString = "(1.0)"; | |
3112 if (1 != jtt.bytecode.BC_f2i01.test(1.0f)) { | |
3113 fail(runString); | |
3114 return; | |
3115 } | |
3116 // (-1.06) == -1 | |
3117 runString = "(-1.06)"; | |
3118 if (-1 != jtt.bytecode.BC_f2i01.test(-1.06f)) { | |
3119 fail(runString); | |
3120 return; | |
3121 } | |
3122 // (-156.82742) == -156 | |
3123 runString = "(-156.82742)"; | |
3124 if (-156 != jtt.bytecode.BC_f2i01.test(-156.82742f)) { | |
3125 fail(runString); | |
3126 return; | |
3127 } | |
3128 } catch (Throwable t) { | |
3129 fail(runString, t); | |
3130 return; | |
3131 } | |
3132 pass(); | |
3133 } | |
3134 | |
3135 static void jtt_bytecode_BC_f2i02() { | |
3136 begin("jtt.bytecode.BC_f2i02"); | |
3137 String runString = null; | |
3138 try { | |
3139 // (0) == -2147483648 | |
3140 runString = "(0)"; | |
3141 if (-2147483648 != jtt.bytecode.BC_f2i02.test(0)) { | |
3142 fail(runString); | |
3143 return; | |
3144 } | |
3145 } catch (Throwable t) { | |
3146 fail(runString, t); | |
3147 return; | |
3148 } | |
3149 pass(); | |
3150 } | |
3151 | |
3152 static void jtt_bytecode_BC_f2l01() { | |
3153 begin("jtt.bytecode.BC_f2l01"); | |
3154 String runString = null; | |
3155 try { | |
3156 // (0.0) == 0 | |
3157 runString = "(0.0)"; | |
3158 if (0L != jtt.bytecode.BC_f2l01.test(0.0f)) { | |
3159 fail(runString); | |
3160 return; | |
3161 } | |
3162 // (1.0) == 1 | |
3163 runString = "(1.0)"; | |
3164 if (1L != jtt.bytecode.BC_f2l01.test(1.0f)) { | |
3165 fail(runString); | |
3166 return; | |
3167 } | |
3168 // (-1.06) == -1 | |
3169 runString = "(-1.06)"; | |
3170 if (-1L != jtt.bytecode.BC_f2l01.test(-1.06f)) { | |
3171 fail(runString); | |
3172 return; | |
3173 } | |
3174 // (-156.82742) == -156 | |
3175 runString = "(-156.82742)"; | |
3176 if (-156L != jtt.bytecode.BC_f2l01.test(-156.82742f)) { | |
3177 fail(runString); | |
3178 return; | |
3179 } | |
3180 } catch (Throwable t) { | |
3181 fail(runString, t); | |
3182 return; | |
3183 } | |
3184 pass(); | |
3185 } | |
3186 | |
3187 static void jtt_bytecode_BC_f2l02() { | |
3188 begin("jtt.bytecode.BC_f2l02"); | |
3189 String runString = null; | |
3190 try { | |
3191 // (0) == -9223372036854775808 | |
3192 runString = "(0)"; | |
3193 if (-9223372036854775808L != jtt.bytecode.BC_f2l02.test(0)) { | |
3194 fail(runString); | |
3195 return; | |
3196 } | |
3197 } catch (Throwable t) { | |
3198 fail(runString, t); | |
3199 return; | |
3200 } | |
3201 pass(); | |
3202 } | |
3203 | |
3204 static void jtt_bytecode_BC_fadd() { | |
3205 begin("jtt.bytecode.BC_fadd"); | |
3206 String runString = null; | |
3207 try { | |
3208 // (0.0,0.0) == 0.0 | |
3209 runString = "(0.0,0.0)"; | |
3210 if (0.0f != jtt.bytecode.BC_fadd.test(0.0f, 0.0f)) { | |
3211 fail(runString); | |
3212 return; | |
3213 } | |
3214 // (1.0,1.0) == 2.0 | |
3215 runString = "(1.0,1.0)"; | |
3216 if (2.0f != jtt.bytecode.BC_fadd.test(1.0f, 1.0f)) { | |
3217 fail(runString); | |
3218 return; | |
3219 } | |
3220 // (253.11,54.43) == 307.54 | |
3221 runString = "(253.11,54.43)"; | |
3222 if (307.54f != jtt.bytecode.BC_fadd.test(253.11f, 54.43f)) { | |
3223 fail(runString); | |
3224 return; | |
3225 } | |
3226 } catch (Throwable t) { | |
3227 fail(runString, t); | |
3228 return; | |
3229 } | |
3230 pass(); | |
3231 } | |
3232 | |
3233 static void jtt_bytecode_BC_faload() { | |
3234 begin("jtt.bytecode.BC_faload"); | |
3235 String runString = null; | |
3236 try { | |
3237 // (0) == 0.0 | |
3238 runString = "(0)"; | |
3239 if (0.0f != jtt.bytecode.BC_faload.test(0)) { | |
3240 fail(runString); | |
3241 return; | |
3242 } | |
3243 // (1) == -1.1 | |
3244 runString = "(1)"; | |
3245 if (-1.1f != jtt.bytecode.BC_faload.test(1)) { | |
3246 fail(runString); | |
3247 return; | |
3248 } | |
3249 // (2) == 4.32 | |
3250 runString = "(2)"; | |
3251 if (4.32f != jtt.bytecode.BC_faload.test(2)) { | |
3252 fail(runString); | |
3253 return; | |
3254 } | |
3255 // (3) == 6.06 | |
3256 runString = "(3)"; | |
3257 if (6.06f != jtt.bytecode.BC_faload.test(3)) { | |
3258 fail(runString); | |
3259 return; | |
3260 } | |
3261 } catch (Throwable t) { | |
3262 fail(runString, t); | |
3263 return; | |
3264 } | |
3265 pass(); | |
3266 } | |
3267 | |
3268 static void jtt_bytecode_BC_fastore() { | |
3269 begin("jtt.bytecode.BC_fastore"); | |
3270 String runString = null; | |
3271 try { | |
3272 // (0,0.01) == 0.01 | |
3273 runString = "(0,0.01)"; | |
3274 if (0.01f != jtt.bytecode.BC_fastore.test(0, 0.01f)) { | |
3275 fail(runString); | |
3276 return; | |
3277 } | |
3278 // (1,-1.4) == -1.4 | |
3279 runString = "(1,-1.4)"; | |
3280 if (-1.4f != jtt.bytecode.BC_fastore.test(1, -1.4f)) { | |
3281 fail(runString); | |
3282 return; | |
3283 } | |
3284 // (2,0.01) == 0.01 | |
3285 runString = "(2,0.01)"; | |
3286 if (0.01f != jtt.bytecode.BC_fastore.test(2, 0.01f)) { | |
3287 fail(runString); | |
3288 return; | |
3289 } | |
3290 // (3,-1.4) == -1.4 | |
3291 runString = "(3,-1.4)"; | |
3292 if (-1.4f != jtt.bytecode.BC_fastore.test(3, -1.4f)) { | |
3293 fail(runString); | |
3294 return; | |
3295 } | |
3296 } catch (Throwable t) { | |
3297 fail(runString, t); | |
3298 return; | |
3299 } | |
3300 pass(); | |
3301 } | |
3302 | |
3303 static void jtt_bytecode_BC_fcmp01() { | |
3304 begin("jtt.bytecode.BC_fcmp01"); | |
3305 String runString = null; | |
3306 try { | |
3307 // (0.0,-0.1) == false | |
3308 runString = "(0.0,-0.1)"; | |
3309 if (false != jtt.bytecode.BC_fcmp01.test(0.0f, -0.1f)) { | |
3310 fail(runString); | |
3311 return; | |
3312 } | |
3313 // (78.0,78.001) == true | |
3314 runString = "(78.0,78.001)"; | |
3315 if (true != jtt.bytecode.BC_fcmp01.test(78.0f, 78.001f)) { | |
3316 fail(runString); | |
3317 return; | |
3318 } | |
3319 } catch (Throwable t) { | |
3320 fail(runString, t); | |
3321 return; | |
3322 } | |
3323 pass(); | |
3324 } | |
3325 | |
3326 static void jtt_bytecode_BC_fcmp02() { | |
3327 begin("jtt.bytecode.BC_fcmp02"); | |
3328 String runString = null; | |
3329 try { | |
3330 // (-1.0) == false | |
3331 runString = "(-1.0)"; | |
3332 if (false != jtt.bytecode.BC_fcmp02.test(-1.0f)) { | |
3333 fail(runString); | |
3334 return; | |
3335 } | |
3336 // (1.0) == false | |
3337 runString = "(1.0)"; | |
3338 if (false != jtt.bytecode.BC_fcmp02.test(1.0f)) { | |
3339 fail(runString); | |
3340 return; | |
3341 } | |
3342 // (0.0) == false | |
3343 runString = "(0.0)"; | |
3344 if (false != jtt.bytecode.BC_fcmp02.test(0.0f)) { | |
3345 fail(runString); | |
3346 return; | |
3347 } | |
3348 } catch (Throwable t) { | |
3349 fail(runString, t); | |
3350 return; | |
3351 } | |
3352 pass(); | |
3353 } | |
3354 | |
3355 static void jtt_bytecode_BC_fcmp03() { | |
3356 begin("jtt.bytecode.BC_fcmp03"); | |
3357 String runString = null; | |
3358 try { | |
3359 // (-1.0) == true | |
3360 runString = "(-1.0)"; | |
3361 if (true != jtt.bytecode.BC_fcmp03.test(-1.0f)) { | |
3362 fail(runString); | |
3363 return; | |
3364 } | |
3365 // (1.0) == true | |
3366 runString = "(1.0)"; | |
3367 if (true != jtt.bytecode.BC_fcmp03.test(1.0f)) { | |
3368 fail(runString); | |
3369 return; | |
3370 } | |
3371 // (0.0) == false | |
3372 runString = "(0.0)"; | |
3373 if (false != jtt.bytecode.BC_fcmp03.test(0.0f)) { | |
3374 fail(runString); | |
3375 return; | |
3376 } | |
3377 } catch (Throwable t) { | |
3378 fail(runString, t); | |
3379 return; | |
3380 } | |
3381 pass(); | |
3382 } | |
3383 | |
3384 static void jtt_bytecode_BC_fcmp04() { | |
3385 begin("jtt.bytecode.BC_fcmp04"); | |
3386 String runString = null; | |
3387 try { | |
3388 // (-1.0) == false | |
3389 runString = "(-1.0)"; | |
3390 if (false != jtt.bytecode.BC_fcmp04.test(-1.0f)) { | |
3391 fail(runString); | |
3392 return; | |
3393 } | |
3394 // (1.0) == false | |
3395 runString = "(1.0)"; | |
3396 if (false != jtt.bytecode.BC_fcmp04.test(1.0f)) { | |
3397 fail(runString); | |
3398 return; | |
3399 } | |
3400 // (0.0) == false | |
3401 runString = "(0.0)"; | |
3402 if (false != jtt.bytecode.BC_fcmp04.test(0.0f)) { | |
3403 fail(runString); | |
3404 return; | |
3405 } | |
3406 } catch (Throwable t) { | |
3407 fail(runString, t); | |
3408 return; | |
3409 } | |
3410 pass(); | |
3411 } | |
3412 | |
3413 static void jtt_bytecode_BC_fcmp05() { | |
3414 begin("jtt.bytecode.BC_fcmp05"); | |
3415 String runString = null; | |
3416 try { | |
3417 // (-1.0) == true | |
3418 runString = "(-1.0)"; | |
3419 if (true != jtt.bytecode.BC_fcmp05.test(-1.0f)) { | |
3420 fail(runString); | |
3421 return; | |
3422 } | |
3423 // (1.0) == true | |
3424 runString = "(1.0)"; | |
3425 if (true != jtt.bytecode.BC_fcmp05.test(1.0f)) { | |
3426 fail(runString); | |
3427 return; | |
3428 } | |
3429 // (0.0) == false | |
3430 runString = "(0.0)"; | |
3431 if (false != jtt.bytecode.BC_fcmp05.test(0.0f)) { | |
3432 fail(runString); | |
3433 return; | |
3434 } | |
3435 } catch (Throwable t) { | |
3436 fail(runString, t); | |
3437 return; | |
3438 } | |
3439 pass(); | |
3440 } | |
3441 | |
3442 static void jtt_bytecode_BC_fcmp06() { | |
3443 begin("jtt.bytecode.BC_fcmp06"); | |
3444 String runString = null; | |
3445 try { | |
3446 // (-1.0) == true | |
3447 runString = "(-1.0)"; | |
3448 if (true != jtt.bytecode.BC_fcmp06.test(-1.0f)) { | |
3449 fail(runString); | |
3450 return; | |
3451 } | |
3452 // (1.0) == true | |
3453 runString = "(1.0)"; | |
3454 if (true != jtt.bytecode.BC_fcmp06.test(1.0f)) { | |
3455 fail(runString); | |
3456 return; | |
3457 } | |
3458 // (0.0) == false | |
3459 runString = "(0.0)"; | |
3460 if (false != jtt.bytecode.BC_fcmp06.test(0.0f)) { | |
3461 fail(runString); | |
3462 return; | |
3463 } | |
3464 } catch (Throwable t) { | |
3465 fail(runString, t); | |
3466 return; | |
3467 } | |
3468 pass(); | |
3469 } | |
3470 | |
3471 static void jtt_bytecode_BC_fcmp07() { | |
3472 begin("jtt.bytecode.BC_fcmp07"); | |
3473 String runString = null; | |
3474 try { | |
3475 // (-1.0) == false | |
3476 runString = "(-1.0)"; | |
3477 if (false != jtt.bytecode.BC_fcmp07.test(-1.0f)) { | |
3478 fail(runString); | |
3479 return; | |
3480 } | |
3481 // (1.0) == false | |
3482 runString = "(1.0)"; | |
3483 if (false != jtt.bytecode.BC_fcmp07.test(1.0f)) { | |
3484 fail(runString); | |
3485 return; | |
3486 } | |
3487 // (0.0) == false | |
3488 runString = "(0.0)"; | |
3489 if (false != jtt.bytecode.BC_fcmp07.test(0.0f)) { | |
3490 fail(runString); | |
3491 return; | |
3492 } | |
3493 } catch (Throwable t) { | |
3494 fail(runString, t); | |
3495 return; | |
3496 } | |
3497 pass(); | |
3498 } | |
3499 | |
3500 static void jtt_bytecode_BC_fcmp08() { | |
3501 begin("jtt.bytecode.BC_fcmp08"); | |
3502 String runString = null; | |
3503 try { | |
3504 // (-1.0) == true | |
3505 runString = "(-1.0)"; | |
3506 if (true != jtt.bytecode.BC_fcmp08.test(-1.0f)) { | |
3507 fail(runString); | |
3508 return; | |
3509 } | |
3510 // (1.0) == true | |
3511 runString = "(1.0)"; | |
3512 if (true != jtt.bytecode.BC_fcmp08.test(1.0f)) { | |
3513 fail(runString); | |
3514 return; | |
3515 } | |
3516 // (0.0) == false | |
3517 runString = "(0.0)"; | |
3518 if (false != jtt.bytecode.BC_fcmp08.test(0.0f)) { | |
3519 fail(runString); | |
3520 return; | |
3521 } | |
3522 } catch (Throwable t) { | |
3523 fail(runString, t); | |
3524 return; | |
3525 } | |
3526 pass(); | |
3527 } | |
3528 | |
3529 static void jtt_bytecode_BC_fcmp09() { | |
3530 begin("jtt.bytecode.BC_fcmp09"); | |
3531 String runString = null; | |
3532 try { | |
3533 // (-1.0) == false | |
3534 runString = "(-1.0)"; | |
3535 if (false != jtt.bytecode.BC_fcmp09.test(-1.0f)) { | |
3536 fail(runString); | |
3537 return; | |
3538 } | |
3539 // (1.0) == false | |
3540 runString = "(1.0)"; | |
3541 if (false != jtt.bytecode.BC_fcmp09.test(1.0f)) { | |
3542 fail(runString); | |
3543 return; | |
3544 } | |
3545 // (0.0) == false | |
3546 runString = "(0.0)"; | |
3547 if (false != jtt.bytecode.BC_fcmp09.test(0.0f)) { | |
3548 fail(runString); | |
3549 return; | |
3550 } | |
3551 } catch (Throwable t) { | |
3552 fail(runString, t); | |
3553 return; | |
3554 } | |
3555 pass(); | |
3556 } | |
3557 | |
3558 static void jtt_bytecode_BC_fcmp10() { | |
3559 begin("jtt.bytecode.BC_fcmp10"); | |
3560 String runString = null; | |
3561 try { | |
3562 // (0) == false | |
3563 runString = "(0)"; | |
3564 if (false != jtt.bytecode.BC_fcmp10.test(0)) { | |
3565 fail(runString); | |
3566 return; | |
3567 } | |
3568 // (1) == true | |
3569 runString = "(1)"; | |
3570 if (true != jtt.bytecode.BC_fcmp10.test(1)) { | |
3571 fail(runString); | |
3572 return; | |
3573 } | |
3574 // (2) == true | |
3575 runString = "(2)"; | |
3576 if (true != jtt.bytecode.BC_fcmp10.test(2)) { | |
3577 fail(runString); | |
3578 return; | |
3579 } | |
3580 // (3) == false | |
3581 runString = "(3)"; | |
3582 if (false != jtt.bytecode.BC_fcmp10.test(3)) { | |
3583 fail(runString); | |
3584 return; | |
3585 } | |
3586 // (4) == true | |
3587 runString = "(4)"; | |
3588 if (true != jtt.bytecode.BC_fcmp10.test(4)) { | |
3589 fail(runString); | |
3590 return; | |
3591 } | |
3592 // (5) == true | |
3593 runString = "(5)"; | |
3594 if (true != jtt.bytecode.BC_fcmp10.test(5)) { | |
3595 fail(runString); | |
3596 return; | |
3597 } | |
3598 // (6) == false | |
3599 runString = "(6)"; | |
3600 if (false != jtt.bytecode.BC_fcmp10.test(6)) { | |
3601 fail(runString); | |
3602 return; | |
3603 } | |
3604 // (7) == false | |
3605 runString = "(7)"; | |
3606 if (false != jtt.bytecode.BC_fcmp10.test(7)) { | |
3607 fail(runString); | |
3608 return; | |
3609 } | |
3610 // (8) == false | |
3611 runString = "(8)"; | |
3612 if (false != jtt.bytecode.BC_fcmp10.test(8)) { | |
3613 fail(runString); | |
3614 return; | |
3615 } | |
3616 } catch (Throwable t) { | |
3617 fail(runString, t); | |
3618 return; | |
3619 } | |
3620 pass(); | |
3621 } | |
3622 | |
3623 static void jtt_bytecode_BC_fdiv() { | |
3624 begin("jtt.bytecode.BC_fdiv"); | |
3625 String runString = null; | |
3626 try { | |
3627 // (311.0,10.0) == 31.1 | |
3628 runString = "(311.0,10.0)"; | |
3629 if (31.1f != jtt.bytecode.BC_fdiv.test(311.0f, 10.0f)) { | |
3630 fail(runString); | |
3631 return; | |
3632 } | |
3633 } catch (Throwable t) { | |
3634 fail(runString, t); | |
3635 return; | |
3636 } | |
3637 pass(); | |
3638 } | |
3639 | |
3640 static void jtt_bytecode_BC_fload() { | |
3641 begin("jtt.bytecode.BC_fload"); | |
3642 String runString = null; | |
3643 try { | |
3644 // (-1.0) == -1.0 | |
3645 runString = "(-1.0)"; | |
3646 if (-1.0f != jtt.bytecode.BC_fload.test(-1.0f)) { | |
3647 fail(runString); | |
3648 return; | |
3649 } | |
3650 // (-1.01) == -1.01 | |
3651 runString = "(-1.01)"; | |
3652 if (-1.01f != jtt.bytecode.BC_fload.test(-1.01f)) { | |
3653 fail(runString); | |
3654 return; | |
3655 } | |
3656 } catch (Throwable t) { | |
3657 fail(runString, t); | |
3658 return; | |
3659 } | |
3660 pass(); | |
3661 } | |
3662 | |
3663 static void jtt_bytecode_BC_fload_2() { | |
3664 begin("jtt.bytecode.BC_fload_2"); | |
3665 String runString = null; | |
3666 try { | |
3667 // (0.0,-1.0) == -1.0 | |
3668 runString = "(0.0,-1.0)"; | |
3669 if (-1.0f != jtt.bytecode.BC_fload_2.test(0.0f, -1.0f)) { | |
3670 fail(runString); | |
3671 return; | |
3672 } | |
3673 // (0.0,-1.01) == -1.01 | |
3674 runString = "(0.0,-1.01)"; | |
3675 if (-1.01f != jtt.bytecode.BC_fload_2.test(0.0f, -1.01f)) { | |
3676 fail(runString); | |
3677 return; | |
3678 } | |
3679 } catch (Throwable t) { | |
3680 fail(runString, t); | |
3681 return; | |
3682 } | |
3683 pass(); | |
3684 } | |
3685 | |
3686 static void jtt_bytecode_BC_fmul() { | |
3687 begin("jtt.bytecode.BC_fmul"); | |
3688 String runString = null; | |
3689 try { | |
3690 // (311.0,10.0) == 3110.0 | |
3691 runString = "(311.0,10.0)"; | |
3692 if (3110.0f != jtt.bytecode.BC_fmul.test(311.0f, 10.0f)) { | |
3693 fail(runString); | |
3694 return; | |
3695 } | |
3696 } catch (Throwable t) { | |
3697 fail(runString, t); | |
3698 return; | |
3699 } | |
3700 pass(); | |
3701 } | |
3702 | |
3703 static void jtt_bytecode_BC_fneg() { | |
3704 begin("jtt.bytecode.BC_fneg"); | |
3705 String runString = null; | |
3706 try { | |
3707 // (0.0) == -0.0 | |
3708 runString = "(0.0)"; | |
3709 if (-0.0f != jtt.bytecode.BC_fneg.test(0.0f)) { | |
3710 fail(runString); | |
3711 return; | |
3712 } | |
3713 // (-1.01) == 1.01 | |
3714 runString = "(-1.01)"; | |
3715 if (1.01f != jtt.bytecode.BC_fneg.test(-1.01f)) { | |
3716 fail(runString); | |
3717 return; | |
3718 } | |
3719 // (7263.8735) == -7263.8735 | |
3720 runString = "(7263.8735)"; | |
3721 if (-7263.8735f != jtt.bytecode.BC_fneg.test(7263.8735f)) { | |
3722 fail(runString); | |
3723 return; | |
3724 } | |
3725 } catch (Throwable t) { | |
3726 fail(runString, t); | |
3727 return; | |
3728 } | |
3729 pass(); | |
3730 } | |
3731 | |
3732 static void jtt_bytecode_BC_frem() { | |
3733 begin("jtt.bytecode.BC_frem"); | |
3734 String runString = null; | |
3735 try { | |
3736 // (311.0,10.0) == 1.0 | |
3737 runString = "(311.0,10.0)"; | |
3738 if (1.0f != jtt.bytecode.BC_frem.test(311.0f, 10.0f)) { | |
3739 fail(runString); | |
3740 return; | |
3741 } | |
3742 // (12.5,6.0) == 0.5 | |
3743 runString = "(12.5,6.0)"; | |
3744 if (0.5f != jtt.bytecode.BC_frem.test(12.5f, 6.0f)) { | |
3745 fail(runString); | |
3746 return; | |
3747 } | |
3748 } catch (Throwable t) { | |
3749 fail(runString, t); | |
3750 return; | |
3751 } | |
3752 pass(); | |
3753 } | |
3754 | |
3755 static void jtt_bytecode_BC_freturn() { | |
3756 begin("jtt.bytecode.BC_freturn"); | |
3757 String runString = null; | |
3758 try { | |
3759 // (0.0) == 0.0 | |
3760 runString = "(0.0)"; | |
3761 if (0.0f != jtt.bytecode.BC_freturn.test(0.0f)) { | |
3762 fail(runString); | |
3763 return; | |
3764 } | |
3765 // (1.1) == 1.1 | |
3766 runString = "(1.1)"; | |
3767 if (1.1f != jtt.bytecode.BC_freturn.test(1.1f)) { | |
3768 fail(runString); | |
3769 return; | |
3770 } | |
3771 // (-1.4) == -1.4 | |
3772 runString = "(-1.4)"; | |
3773 if (-1.4f != jtt.bytecode.BC_freturn.test(-1.4f)) { | |
3774 fail(runString); | |
3775 return; | |
3776 } | |
3777 // (256.33) == 256.33 | |
3778 runString = "(256.33)"; | |
3779 if (256.33f != jtt.bytecode.BC_freturn.test(256.33f)) { | |
3780 fail(runString); | |
3781 return; | |
3782 } | |
3783 // (1000.001) == 1000.001 | |
3784 runString = "(1000.001)"; | |
3785 if (1000.001f != jtt.bytecode.BC_freturn.test(1000.001f)) { | |
3786 fail(runString); | |
3787 return; | |
3788 } | |
3789 } catch (Throwable t) { | |
3790 fail(runString, t); | |
3791 return; | |
3792 } | |
3793 pass(); | |
3794 } | |
3795 | |
3796 static void jtt_bytecode_BC_fsub() { | |
3797 begin("jtt.bytecode.BC_fsub"); | |
3798 String runString = null; | |
3799 try { | |
3800 // (0.0,0.0) == 0.0 | |
3801 runString = "(0.0,0.0)"; | |
3802 if (0.0f != jtt.bytecode.BC_fsub.test(0.0f, 0.0f)) { | |
3803 fail(runString); | |
3804 return; | |
3805 } | |
3806 // (1.0,1.0) == 0.0 | |
3807 runString = "(1.0,1.0)"; | |
3808 if (0.0f != jtt.bytecode.BC_fsub.test(1.0f, 1.0f)) { | |
3809 fail(runString); | |
3810 return; | |
3811 } | |
3812 // (253.11,54.43) == 198.68 | |
3813 runString = "(253.11,54.43)"; | |
3814 if (198.68f != jtt.bytecode.BC_fsub.test(253.11f, 54.43f)) { | |
3815 fail(runString); | |
3816 return; | |
3817 } | |
3818 } catch (Throwable t) { | |
3819 fail(runString, t); | |
3820 return; | |
3821 } | |
3822 pass(); | |
3823 } | |
3824 | |
3825 static void jtt_bytecode_BC_getfield() { | |
3826 begin("jtt.bytecode.BC_getfield"); | |
3827 String runString = null; | |
3828 try { | |
3829 // (0) == 13 | |
3830 runString = "(0)"; | |
3831 if (13 != jtt.bytecode.BC_getfield.test(0)) { | |
3832 fail(runString); | |
3833 return; | |
3834 } | |
3835 } catch (Throwable t) { | |
3836 fail(runString, t); | |
3837 return; | |
3838 } | |
3839 pass(); | |
3840 } | |
3841 | |
3842 static void jtt_bytecode_BC_getstatic_b() { | |
3843 begin("jtt.bytecode.BC_getstatic_b"); | |
3844 String runString = null; | |
3845 try { | |
3846 // (0) == 11 | |
3847 runString = "(0)"; | |
3848 if ((byte) 11 != jtt.bytecode.BC_getstatic_b.test(0)) { | |
3849 fail(runString); | |
3850 return; | |
3851 } | |
3852 // (1) == 11 | |
3853 runString = "(1)"; | |
3854 if ((byte) 11 != jtt.bytecode.BC_getstatic_b.test(1)) { | |
3855 fail(runString); | |
3856 return; | |
3857 } | |
3858 // (2) == 11 | |
3859 runString = "(2)"; | |
3860 if ((byte) 11 != jtt.bytecode.BC_getstatic_b.test(2)) { | |
3861 fail(runString); | |
3862 return; | |
3863 } | |
3864 } catch (Throwable t) { | |
3865 fail(runString, t); | |
3866 return; | |
3867 } | |
3868 pass(); | |
3869 } | |
3870 | |
3871 static void jtt_bytecode_BC_getstatic_c() { | |
3872 begin("jtt.bytecode.BC_getstatic_c"); | |
3873 String runString = null; | |
3874 try { | |
3875 // (0) == '\13' | |
3876 runString = "(0)"; | |
3877 if ((char) 11 != jtt.bytecode.BC_getstatic_c.test(0)) { | |
3878 fail(runString); | |
3879 return; | |
3880 } | |
3881 // (1) == '\13' | |
3882 runString = "(1)"; | |
3883 if ((char) 11 != jtt.bytecode.BC_getstatic_c.test(1)) { | |
3884 fail(runString); | |
3885 return; | |
3886 } | |
3887 } catch (Throwable t) { | |
3888 fail(runString, t); | |
3889 return; | |
3890 } | |
3891 pass(); | |
3892 } | |
3893 | |
3894 static void jtt_bytecode_BC_getstatic_d() { | |
3895 begin("jtt.bytecode.BC_getstatic_d"); | |
3896 String runString = null; | |
3897 try { | |
3898 // (0) == 11.0 | |
3899 runString = "(0)"; | |
3900 if (11.0 != jtt.bytecode.BC_getstatic_d.test(0)) { | |
3901 fail(runString); | |
3902 return; | |
3903 } | |
3904 // (1) == 11.0 | |
3905 runString = "(1)"; | |
3906 if (11.0 != jtt.bytecode.BC_getstatic_d.test(1)) { | |
3907 fail(runString); | |
3908 return; | |
3909 } | |
3910 } catch (Throwable t) { | |
3911 fail(runString, t); | |
3912 return; | |
3913 } | |
3914 pass(); | |
3915 } | |
3916 | |
3917 static void jtt_bytecode_BC_getstatic_f() { | |
3918 begin("jtt.bytecode.BC_getstatic_f"); | |
3919 String runString = null; | |
3920 try { | |
3921 // (0) == 11.0 | |
3922 runString = "(0)"; | |
3923 if (11.0f != jtt.bytecode.BC_getstatic_f.test(0)) { | |
3924 fail(runString); | |
3925 return; | |
3926 } | |
3927 // (1) == 11.0 | |
3928 runString = "(1)"; | |
3929 if (11.0f != jtt.bytecode.BC_getstatic_f.test(1)) { | |
3930 fail(runString); | |
3931 return; | |
3932 } | |
3933 } catch (Throwable t) { | |
3934 fail(runString, t); | |
3935 return; | |
3936 } | |
3937 pass(); | |
3938 } | |
3939 | |
3940 static void jtt_bytecode_BC_getstatic_i() { | |
3941 begin("jtt.bytecode.BC_getstatic_i"); | |
3942 String runString = null; | |
3943 try { | |
3944 // (0) == 11 | |
3945 runString = "(0)"; | |
3946 if (11 != jtt.bytecode.BC_getstatic_i.test(0)) { | |
3947 fail(runString); | |
3948 return; | |
3949 } | |
3950 // (1) == 11 | |
3951 runString = "(1)"; | |
3952 if (11 != jtt.bytecode.BC_getstatic_i.test(1)) { | |
3953 fail(runString); | |
3954 return; | |
3955 } | |
3956 // (2) == 11 | |
3957 runString = "(2)"; | |
3958 if (11 != jtt.bytecode.BC_getstatic_i.test(2)) { | |
3959 fail(runString); | |
3960 return; | |
3961 } | |
3962 // (3) == 11 | |
3963 runString = "(3)"; | |
3964 if (11 != jtt.bytecode.BC_getstatic_i.test(3)) { | |
3965 fail(runString); | |
3966 return; | |
3967 } | |
3968 // (-4) == 11 | |
3969 runString = "(-4)"; | |
3970 if (11 != jtt.bytecode.BC_getstatic_i.test(-4)) { | |
3971 fail(runString); | |
3972 return; | |
3973 } | |
3974 } catch (Throwable t) { | |
3975 fail(runString, t); | |
3976 return; | |
3977 } | |
3978 pass(); | |
3979 } | |
3980 | |
3981 static void jtt_bytecode_BC_getstatic_l() { | |
3982 begin("jtt.bytecode.BC_getstatic_l"); | |
3983 String runString = null; | |
3984 try { | |
3985 // (0) == 11 | |
3986 runString = "(0)"; | |
3987 if (11L != jtt.bytecode.BC_getstatic_l.test(0)) { | |
3988 fail(runString); | |
3989 return; | |
3990 } | |
3991 // (1) == 11 | |
3992 runString = "(1)"; | |
3993 if (11L != jtt.bytecode.BC_getstatic_l.test(1)) { | |
3994 fail(runString); | |
3995 return; | |
3996 } | |
3997 } catch (Throwable t) { | |
3998 fail(runString, t); | |
3999 return; | |
4000 } | |
4001 pass(); | |
4002 } | |
4003 | |
4004 static void jtt_bytecode_BC_getstatic_s() { | |
4005 begin("jtt.bytecode.BC_getstatic_s"); | |
4006 String runString = null; | |
4007 try { | |
4008 // (0) == 11 | |
4009 runString = "(0)"; | |
4010 if ((short) 11 != jtt.bytecode.BC_getstatic_s.test(0)) { | |
4011 fail(runString); | |
4012 return; | |
4013 } | |
4014 // (1) == 11 | |
4015 runString = "(1)"; | |
4016 if ((short) 11 != jtt.bytecode.BC_getstatic_s.test(1)) { | |
4017 fail(runString); | |
4018 return; | |
4019 } | |
4020 } catch (Throwable t) { | |
4021 fail(runString, t); | |
4022 return; | |
4023 } | |
4024 pass(); | |
4025 } | |
4026 | |
4027 static void jtt_bytecode_BC_getstatic_z() { | |
4028 begin("jtt.bytecode.BC_getstatic_z"); | |
4029 String runString = null; | |
4030 try { | |
4031 // (0) == true | |
4032 runString = "(0)"; | |
4033 if (true != jtt.bytecode.BC_getstatic_z.test(0)) { | |
4034 fail(runString); | |
4035 return; | |
4036 } | |
4037 // (1) == true | |
4038 runString = "(1)"; | |
4039 if (true != jtt.bytecode.BC_getstatic_z.test(1)) { | |
4040 fail(runString); | |
4041 return; | |
4042 } | |
4043 } catch (Throwable t) { | |
4044 fail(runString, t); | |
4045 return; | |
4046 } | |
4047 pass(); | |
4048 } | |
4049 | |
4050 static void jtt_bytecode_BC_i2b() { | |
4051 begin("jtt.bytecode.BC_i2b"); | |
4052 String runString = null; | |
4053 try { | |
4054 // (-1) == -1 | |
4055 runString = "(-1)"; | |
4056 if ((byte) -1 != jtt.bytecode.BC_i2b.test(-1)) { | |
4057 fail(runString); | |
4058 return; | |
4059 } | |
4060 // (2) == 2 | |
4061 runString = "(2)"; | |
4062 if ((byte) 2 != jtt.bytecode.BC_i2b.test(2)) { | |
4063 fail(runString); | |
4064 return; | |
4065 } | |
4066 // (255) == -1 | |
4067 runString = "(255)"; | |
4068 if ((byte) -1 != jtt.bytecode.BC_i2b.test(255)) { | |
4069 fail(runString); | |
4070 return; | |
4071 } | |
4072 // (128) == -128 | |
4073 runString = "(128)"; | |
4074 if ((byte) -128 != jtt.bytecode.BC_i2b.test(128)) { | |
4075 fail(runString); | |
4076 return; | |
4077 } | |
4078 } catch (Throwable t) { | |
4079 fail(runString, t); | |
4080 return; | |
4081 } | |
4082 pass(); | |
4083 } | |
4084 | |
4085 static void jtt_bytecode_BC_i2c() { | |
4086 begin("jtt.bytecode.BC_i2c"); | |
4087 String runString = null; | |
4088 try { | |
4089 // (-1) == '\177777' | |
4090 runString = "(-1)"; | |
4091 if ((char) 65535 != jtt.bytecode.BC_i2c.test(-1)) { | |
4092 fail(runString); | |
4093 return; | |
4094 } | |
4095 // (645) == '\1205' | |
4096 runString = "(645)"; | |
4097 if ((char) 645 != jtt.bytecode.BC_i2c.test(645)) { | |
4098 fail(runString); | |
4099 return; | |
4100 } | |
4101 // (65535) == '\177777' | |
4102 runString = "(65535)"; | |
4103 if ((char) 65535 != jtt.bytecode.BC_i2c.test(65535)) { | |
4104 fail(runString); | |
4105 return; | |
4106 } | |
4107 } catch (Throwable t) { | |
4108 fail(runString, t); | |
4109 return; | |
4110 } | |
4111 pass(); | |
4112 } | |
4113 | |
4114 static void jtt_bytecode_BC_i2d() { | |
4115 begin("jtt.bytecode.BC_i2d"); | |
4116 String runString = null; | |
4117 try { | |
4118 // (0) == 0.0 | |
4119 runString = "(0)"; | |
4120 if (0.0 != jtt.bytecode.BC_i2d.test(0)) { | |
4121 fail(runString); | |
4122 return; | |
4123 } | |
4124 // (1) == 1.0 | |
4125 runString = "(1)"; | |
4126 if (1.0 != jtt.bytecode.BC_i2d.test(1)) { | |
4127 fail(runString); | |
4128 return; | |
4129 } | |
4130 // (-34) == -34.0 | |
4131 runString = "(-34)"; | |
4132 if (-34.0 != jtt.bytecode.BC_i2d.test(-34)) { | |
4133 fail(runString); | |
4134 return; | |
4135 } | |
4136 } catch (Throwable t) { | |
4137 fail(runString, t); | |
4138 return; | |
4139 } | |
4140 pass(); | |
4141 } | |
4142 | |
4143 static void jtt_bytecode_BC_i2f() { | |
4144 begin("jtt.bytecode.BC_i2f"); | |
4145 String runString = null; | |
4146 try { | |
4147 // (0) == 0.0 | |
4148 runString = "(0)"; | |
4149 if (0.0f != jtt.bytecode.BC_i2f.test(0)) { | |
4150 fail(runString); | |
4151 return; | |
4152 } | |
4153 // (1) == 1.0 | |
4154 runString = "(1)"; | |
4155 if (1.0f != jtt.bytecode.BC_i2f.test(1)) { | |
4156 fail(runString); | |
4157 return; | |
4158 } | |
4159 // (-34) == -34.0 | |
4160 runString = "(-34)"; | |
4161 if (-34.0f != jtt.bytecode.BC_i2f.test(-34)) { | |
4162 fail(runString); | |
4163 return; | |
4164 } | |
4165 } catch (Throwable t) { | |
4166 fail(runString, t); | |
4167 return; | |
4168 } | |
4169 pass(); | |
4170 } | |
4171 | |
4172 static void jtt_bytecode_BC_i2l() { | |
4173 begin("jtt.bytecode.BC_i2l"); | |
4174 String runString = null; | |
4175 try { | |
4176 // (1) == 1 | |
4177 runString = "(1)"; | |
4178 if (1L != jtt.bytecode.BC_i2l.test(1)) { | |
4179 fail(runString); | |
4180 return; | |
4181 } | |
4182 // (2) == 2 | |
4183 runString = "(2)"; | |
4184 if (2L != jtt.bytecode.BC_i2l.test(2)) { | |
4185 fail(runString); | |
4186 return; | |
4187 } | |
4188 // (3) == 3 | |
4189 runString = "(3)"; | |
4190 if (3L != jtt.bytecode.BC_i2l.test(3)) { | |
4191 fail(runString); | |
4192 return; | |
4193 } | |
4194 // (-1) == -1 | |
4195 runString = "(-1)"; | |
4196 if (-1L != jtt.bytecode.BC_i2l.test(-1)) { | |
4197 fail(runString); | |
4198 return; | |
4199 } | |
4200 // (-2147483647) == -2147483647 | |
4201 runString = "(-2147483647)"; | |
4202 if (-2147483647L != jtt.bytecode.BC_i2l.test(-2147483647)) { | |
4203 fail(runString); | |
4204 return; | |
4205 } | |
4206 // (-2147483648) == -2147483648 | |
4207 runString = "(-2147483648)"; | |
4208 if (-2147483648L != jtt.bytecode.BC_i2l.test(-2147483648)) { | |
4209 fail(runString); | |
4210 return; | |
4211 } | |
4212 // (2147483647) == 2147483647 | |
4213 runString = "(2147483647)"; | |
4214 if (2147483647L != jtt.bytecode.BC_i2l.test(2147483647)) { | |
4215 fail(runString); | |
4216 return; | |
4217 } | |
4218 } catch (Throwable t) { | |
4219 fail(runString, t); | |
4220 return; | |
4221 } | |
4222 pass(); | |
4223 } | |
4224 | |
4225 static void jtt_bytecode_BC_i2s() { | |
4226 begin("jtt.bytecode.BC_i2s"); | |
4227 String runString = null; | |
4228 try { | |
4229 // (-1) == -1 | |
4230 runString = "(-1)"; | |
4231 if ((short) -1 != jtt.bytecode.BC_i2s.test(-1)) { | |
4232 fail(runString); | |
4233 return; | |
4234 } | |
4235 // (34) == 34 | |
4236 runString = "(34)"; | |
4237 if ((short) 34 != jtt.bytecode.BC_i2s.test(34)) { | |
4238 fail(runString); | |
4239 return; | |
4240 } | |
4241 // (65535) == -1 | |
4242 runString = "(65535)"; | |
4243 if ((short) -1 != jtt.bytecode.BC_i2s.test(65535)) { | |
4244 fail(runString); | |
4245 return; | |
4246 } | |
4247 // (32768) == -32768 | |
4248 runString = "(32768)"; | |
4249 if ((short) -32768 != jtt.bytecode.BC_i2s.test(32768)) { | |
4250 fail(runString); | |
4251 return; | |
4252 } | |
4253 } catch (Throwable t) { | |
4254 fail(runString, t); | |
4255 return; | |
4256 } | |
4257 pass(); | |
4258 } | |
4259 | |
4260 static void jtt_bytecode_BC_iadd() { | |
4261 begin("jtt.bytecode.BC_iadd"); | |
4262 String runString = null; | |
4263 try { | |
4264 // (1,2) == 3 | |
4265 runString = "(1,2)"; | |
4266 if (3 != jtt.bytecode.BC_iadd.test(1, 2)) { | |
4267 fail(runString); | |
4268 return; | |
4269 } | |
4270 // (0,-1) == -1 | |
4271 runString = "(0,-1)"; | |
4272 if (-1 != jtt.bytecode.BC_iadd.test(0, -1)) { | |
4273 fail(runString); | |
4274 return; | |
4275 } | |
4276 // (33,67) == 100 | |
4277 runString = "(33,67)"; | |
4278 if (100 != jtt.bytecode.BC_iadd.test(33, 67)) { | |
4279 fail(runString); | |
4280 return; | |
4281 } | |
4282 // (1,-1) == 0 | |
4283 runString = "(1,-1)"; | |
4284 if (0 != jtt.bytecode.BC_iadd.test(1, -1)) { | |
4285 fail(runString); | |
4286 return; | |
4287 } | |
4288 // (-2147483648,1) == -2147483647 | |
4289 runString = "(-2147483648,1)"; | |
4290 if (-2147483647 != jtt.bytecode.BC_iadd.test(-2147483648, 1)) { | |
4291 fail(runString); | |
4292 return; | |
4293 } | |
4294 // (2147483647,1) == -2147483648 | |
4295 runString = "(2147483647,1)"; | |
4296 if (-2147483648 != jtt.bytecode.BC_iadd.test(2147483647, 1)) { | |
4297 fail(runString); | |
4298 return; | |
4299 } | |
4300 // (-2147483647,-2) == 2147483647 | |
4301 runString = "(-2147483647,-2)"; | |
4302 if (2147483647 != jtt.bytecode.BC_iadd.test(-2147483647, -2)) { | |
4303 fail(runString); | |
4304 return; | |
4305 } | |
4306 } catch (Throwable t) { | |
4307 fail(runString, t); | |
4308 return; | |
4309 } | |
4310 pass(); | |
4311 } | |
4312 | |
4313 static void jtt_bytecode_BC_iadd2() { | |
4314 begin("jtt.bytecode.BC_iadd2"); | |
4315 String runString = null; | |
4316 try { | |
4317 // (1,2) == 3 | |
4318 runString = "(1,2)"; | |
4319 if (3 != jtt.bytecode.BC_iadd2.test((byte) 1, (byte) 2)) { | |
4320 fail(runString); | |
4321 return; | |
4322 } | |
4323 // (0,-1) == -1 | |
4324 runString = "(0,-1)"; | |
4325 if (-1 != jtt.bytecode.BC_iadd2.test((byte) 0, (byte) -1)) { | |
4326 fail(runString); | |
4327 return; | |
4328 } | |
4329 // (33,67) == 100 | |
4330 runString = "(33,67)"; | |
4331 if (100 != jtt.bytecode.BC_iadd2.test((byte) 33, (byte) 67)) { | |
4332 fail(runString); | |
4333 return; | |
4334 } | |
4335 // (1,-1) == 0 | |
4336 runString = "(1,-1)"; | |
4337 if (0 != jtt.bytecode.BC_iadd2.test((byte) 1, (byte) -1)) { | |
4338 fail(runString); | |
4339 return; | |
4340 } | |
4341 // (-128,1) == -127 | |
4342 runString = "(-128,1)"; | |
4343 if (-127 != jtt.bytecode.BC_iadd2.test((byte) -128, (byte) 1)) { | |
4344 fail(runString); | |
4345 return; | |
4346 } | |
4347 // (127,1) == 128 | |
4348 runString = "(127,1)"; | |
4349 if (128 != jtt.bytecode.BC_iadd2.test((byte) 127, (byte) 1)) { | |
4350 fail(runString); | |
4351 return; | |
4352 } | |
4353 } catch (Throwable t) { | |
4354 fail(runString, t); | |
4355 return; | |
4356 } | |
4357 pass(); | |
4358 } | |
4359 | |
4360 static void jtt_bytecode_BC_iadd3() { | |
4361 begin("jtt.bytecode.BC_iadd3"); | |
4362 String runString = null; | |
4363 try { | |
4364 // (1,2) == 3 | |
4365 runString = "(1,2)"; | |
4366 if (3 != jtt.bytecode.BC_iadd3.test((short) 1, (short) 2)) { | |
4367 fail(runString); | |
4368 return; | |
4369 } | |
4370 // (0,-1) == -1 | |
4371 runString = "(0,-1)"; | |
4372 if (-1 != jtt.bytecode.BC_iadd3.test((short) 0, (short) -1)) { | |
4373 fail(runString); | |
4374 return; | |
4375 } | |
4376 // (33,67) == 100 | |
4377 runString = "(33,67)"; | |
4378 if (100 != jtt.bytecode.BC_iadd3.test((short) 33, (short) 67)) { | |
4379 fail(runString); | |
4380 return; | |
4381 } | |
4382 // (1,-1) == 0 | |
4383 runString = "(1,-1)"; | |
4384 if (0 != jtt.bytecode.BC_iadd3.test((short) 1, (short) -1)) { | |
4385 fail(runString); | |
4386 return; | |
4387 } | |
4388 // (-128,1) == -127 | |
4389 runString = "(-128,1)"; | |
4390 if (-127 != jtt.bytecode.BC_iadd3.test((short) -128, (short) 1)) { | |
4391 fail(runString); | |
4392 return; | |
4393 } | |
4394 // (127,1) == 128 | |
4395 runString = "(127,1)"; | |
4396 if (128 != jtt.bytecode.BC_iadd3.test((short) 127, (short) 1)) { | |
4397 fail(runString); | |
4398 return; | |
4399 } | |
4400 // (-32768,1) == -32767 | |
4401 runString = "(-32768,1)"; | |
4402 if (-32767 != jtt.bytecode.BC_iadd3.test((short) -32768, (short) 1)) { | |
4403 fail(runString); | |
4404 return; | |
4405 } | |
4406 // (32767,1) == 32768 | |
4407 runString = "(32767,1)"; | |
4408 if (32768 != jtt.bytecode.BC_iadd3.test((short) 32767, (short) 1)) { | |
4409 fail(runString); | |
4410 return; | |
4411 } | |
4412 } catch (Throwable t) { | |
4413 fail(runString, t); | |
4414 return; | |
4415 } | |
4416 pass(); | |
4417 } | |
4418 | |
4419 static void jtt_bytecode_BC_iaload() { | |
4420 begin("jtt.bytecode.BC_iaload"); | |
4421 String runString = null; | |
4422 try { | |
4423 // (0) == 0 | |
4424 runString = "(0)"; | |
4425 if (0 != jtt.bytecode.BC_iaload.test(0)) { | |
4426 fail(runString); | |
4427 return; | |
4428 } | |
4429 // (1) == -1 | |
4430 runString = "(1)"; | |
4431 if (-1 != jtt.bytecode.BC_iaload.test(1)) { | |
4432 fail(runString); | |
4433 return; | |
4434 } | |
4435 // (2) == 4 | |
4436 runString = "(2)"; | |
4437 if (4 != jtt.bytecode.BC_iaload.test(2)) { | |
4438 fail(runString); | |
4439 return; | |
4440 } | |
4441 // (3) == 1000000000 | |
4442 runString = "(3)"; | |
4443 if (1000000000 != jtt.bytecode.BC_iaload.test(3)) { | |
4444 fail(runString); | |
4445 return; | |
4446 } | |
4447 } catch (Throwable t) { | |
4448 fail(runString, t); | |
4449 return; | |
4450 } | |
4451 pass(); | |
4452 } | |
4453 | |
4454 static void jtt_bytecode_BC_iand() { | |
4455 begin("jtt.bytecode.BC_iand"); | |
4456 String runString = null; | |
4457 try { | |
4458 // (1,2) == 0 | |
4459 runString = "(1,2)"; | |
4460 if (0 != jtt.bytecode.BC_iand.test(1, 2)) { | |
4461 fail(runString); | |
4462 return; | |
4463 } | |
4464 // (0,-1) == 0 | |
4465 runString = "(0,-1)"; | |
4466 if (0 != jtt.bytecode.BC_iand.test(0, -1)) { | |
4467 fail(runString); | |
4468 return; | |
4469 } | |
4470 // (31,63) == 31 | |
4471 runString = "(31,63)"; | |
4472 if (31 != jtt.bytecode.BC_iand.test(31, 63)) { | |
4473 fail(runString); | |
4474 return; | |
4475 } | |
4476 // (6,4) == 4 | |
4477 runString = "(6,4)"; | |
4478 if (4 != jtt.bytecode.BC_iand.test(6, 4)) { | |
4479 fail(runString); | |
4480 return; | |
4481 } | |
4482 // (-2147483648,1) == 0 | |
4483 runString = "(-2147483648,1)"; | |
4484 if (0 != jtt.bytecode.BC_iand.test(-2147483648, 1)) { | |
4485 fail(runString); | |
4486 return; | |
4487 } | |
4488 } catch (Throwable t) { | |
4489 fail(runString, t); | |
4490 return; | |
4491 } | |
4492 pass(); | |
4493 } | |
4494 | |
4495 static void jtt_bytecode_BC_iastore() { | |
4496 begin("jtt.bytecode.BC_iastore"); | |
4497 String runString = null; | |
4498 try { | |
4499 // (0,0) == 0 | |
4500 runString = "(0,0)"; | |
4501 if (0 != jtt.bytecode.BC_iastore.test(0, 0)) { | |
4502 fail(runString); | |
4503 return; | |
4504 } | |
4505 // (1,-1) == -1 | |
4506 runString = "(1,-1)"; | |
4507 if (-1 != jtt.bytecode.BC_iastore.test(1, -1)) { | |
4508 fail(runString); | |
4509 return; | |
4510 } | |
4511 // (2,11) == 11 | |
4512 runString = "(2,11)"; | |
4513 if (11 != jtt.bytecode.BC_iastore.test(2, 11)) { | |
4514 fail(runString); | |
4515 return; | |
4516 } | |
4517 // (3,-14) == -14 | |
4518 runString = "(3,-14)"; | |
4519 if (-14 != jtt.bytecode.BC_iastore.test(3, -14)) { | |
4520 fail(runString); | |
4521 return; | |
4522 } | |
4523 } catch (Throwable t) { | |
4524 fail(runString, t); | |
4525 return; | |
4526 } | |
4527 pass(); | |
4528 } | |
4529 | |
4530 static void jtt_bytecode_BC_iconst() { | |
4531 begin("jtt.bytecode.BC_iconst"); | |
4532 String runString = null; | |
4533 try { | |
4534 // (0) == 0 | |
4535 runString = "(0)"; | |
4536 if (0 != jtt.bytecode.BC_iconst.test(0)) { | |
4537 fail(runString); | |
4538 return; | |
4539 } | |
4540 // (1) == 1 | |
4541 runString = "(1)"; | |
4542 if (1 != jtt.bytecode.BC_iconst.test(1)) { | |
4543 fail(runString); | |
4544 return; | |
4545 } | |
4546 // (2) == 2 | |
4547 runString = "(2)"; | |
4548 if (2 != jtt.bytecode.BC_iconst.test(2)) { | |
4549 fail(runString); | |
4550 return; | |
4551 } | |
4552 // (3) == 3 | |
4553 runString = "(3)"; | |
4554 if (3 != jtt.bytecode.BC_iconst.test(3)) { | |
4555 fail(runString); | |
4556 return; | |
4557 } | |
4558 // (4) == 4 | |
4559 runString = "(4)"; | |
4560 if (4 != jtt.bytecode.BC_iconst.test(4)) { | |
4561 fail(runString); | |
4562 return; | |
4563 } | |
4564 // (5) == 5 | |
4565 runString = "(5)"; | |
4566 if (5 != jtt.bytecode.BC_iconst.test(5)) { | |
4567 fail(runString); | |
4568 return; | |
4569 } | |
4570 // (6) == 375 | |
4571 runString = "(6)"; | |
4572 if (375 != jtt.bytecode.BC_iconst.test(6)) { | |
4573 fail(runString); | |
4574 return; | |
4575 } | |
4576 } catch (Throwable t) { | |
4577 fail(runString, t); | |
4578 return; | |
4579 } | |
4580 pass(); | |
4581 } | |
4582 | |
4583 static void jtt_bytecode_BC_idiv() { | |
4584 begin("jtt.bytecode.BC_idiv"); | |
4585 String runString = null; | |
4586 try { | |
4587 // (1,2) == 0 | |
4588 runString = "(1,2)"; | |
4589 if (0 != jtt.bytecode.BC_idiv.test(1, 2)) { | |
4590 fail(runString); | |
4591 return; | |
4592 } | |
4593 // (2,-1) == -2 | |
4594 runString = "(2,-1)"; | |
4595 if (-2 != jtt.bytecode.BC_idiv.test(2, -1)) { | |
4596 fail(runString); | |
4597 return; | |
4598 } | |
4599 // (256,4) == 64 | |
4600 runString = "(256,4)"; | |
4601 if (64 != jtt.bytecode.BC_idiv.test(256, 4)) { | |
4602 fail(runString); | |
4603 return; | |
4604 } | |
4605 // (135,7) == 19 | |
4606 runString = "(135,7)"; | |
4607 if (19 != jtt.bytecode.BC_idiv.test(135, 7)) { | |
4608 fail(runString); | |
4609 return; | |
4610 } | |
4611 } catch (Throwable t) { | |
4612 fail(runString, t); | |
4613 return; | |
4614 } | |
4615 pass(); | |
4616 } | |
4617 | |
4618 static void jtt_bytecode_BC_idiv2() { | |
4619 begin("jtt.bytecode.BC_idiv2"); | |
4620 String runString = null; | |
4621 try { | |
4622 // (-2147483648,-1) == -2147483648 | |
4623 runString = "(-2147483648,-1)"; | |
4624 if (-2147483648 != jtt.bytecode.BC_idiv2.test(-2147483648, -1)) { | |
4625 fail(runString); | |
4626 return; | |
4627 } | |
4628 // (-2147483648,1) == -2147483648 | |
4629 runString = "(-2147483648,1)"; | |
4630 if (-2147483648 != jtt.bytecode.BC_idiv2.test(-2147483648, 1)) { | |
4631 fail(runString); | |
4632 return; | |
4633 } | |
4634 } catch (Throwable t) { | |
4635 fail(runString, t); | |
4636 return; | |
4637 } | |
4638 pass(); | |
4639 } | |
4640 | |
4641 static void jtt_bytecode_BC_ifeq() { | |
4642 begin("jtt.bytecode.BC_ifeq"); | |
4643 String runString = null; | |
4644 try { | |
4645 // (0) == 2 | |
4646 runString = "(0)"; | |
4647 if (2 != jtt.bytecode.BC_ifeq.test(0)) { | |
4648 fail(runString); | |
4649 return; | |
4650 } | |
4651 // (1) == -2 | |
4652 runString = "(1)"; | |
4653 if (-2 != jtt.bytecode.BC_ifeq.test(1)) { | |
4654 fail(runString); | |
4655 return; | |
4656 } | |
4657 } catch (Throwable t) { | |
4658 fail(runString, t); | |
4659 return; | |
4660 } | |
4661 pass(); | |
4662 } | |
4663 | |
4664 static void jtt_bytecode_BC_ifeq_2() { | |
4665 begin("jtt.bytecode.BC_ifeq_2"); | |
4666 String runString = null; | |
4667 try { | |
4668 // (0) == true | |
4669 runString = "(0)"; | |
4670 if (true != jtt.bytecode.BC_ifeq_2.test(0)) { | |
4671 fail(runString); | |
4672 return; | |
4673 } | |
4674 // (1) == false | |
4675 runString = "(1)"; | |
4676 if (false != jtt.bytecode.BC_ifeq_2.test(1)) { | |
4677 fail(runString); | |
4678 return; | |
4679 } | |
4680 } catch (Throwable t) { | |
4681 fail(runString, t); | |
4682 return; | |
4683 } | |
4684 pass(); | |
4685 } | |
4686 | |
4687 static void jtt_bytecode_BC_ifeq_3() { | |
4688 begin("jtt.bytecode.BC_ifeq_3"); | |
4689 String runString = null; | |
4690 try { | |
4691 // (0) == false | |
4692 runString = "(0)"; | |
4693 if (false != jtt.bytecode.BC_ifeq_3.test(0)) { | |
4694 fail(runString); | |
4695 return; | |
4696 } | |
4697 // (1) == true | |
4698 runString = "(1)"; | |
4699 if (true != jtt.bytecode.BC_ifeq_3.test(1)) { | |
4700 fail(runString); | |
4701 return; | |
4702 } | |
4703 } catch (Throwable t) { | |
4704 fail(runString, t); | |
4705 return; | |
4706 } | |
4707 pass(); | |
4708 } | |
4709 | |
4710 static void jtt_bytecode_BC_ifge() { | |
4711 begin("jtt.bytecode.BC_ifge"); | |
4712 String runString = null; | |
4713 try { | |
4714 // (0) == 2 | |
4715 runString = "(0)"; | |
4716 if (2 != jtt.bytecode.BC_ifge.test(0)) { | |
4717 fail(runString); | |
4718 return; | |
4719 } | |
4720 // (1) == 2 | |
4721 runString = "(1)"; | |
4722 if (2 != jtt.bytecode.BC_ifge.test(1)) { | |
4723 fail(runString); | |
4724 return; | |
4725 } | |
4726 } catch (Throwable t) { | |
4727 fail(runString, t); | |
4728 return; | |
4729 } | |
4730 pass(); | |
4731 } | |
4732 | |
4733 static void jtt_bytecode_BC_ifge_2() { | |
4734 begin("jtt.bytecode.BC_ifge_2"); | |
4735 String runString = null; | |
4736 try { | |
4737 // (0,1) == false | |
4738 runString = "(0,1)"; | |
4739 if (false != jtt.bytecode.BC_ifge_2.test(0, 1)) { | |
4740 fail(runString); | |
4741 return; | |
4742 } | |
4743 // (1,0) == true | |
4744 runString = "(1,0)"; | |
4745 if (true != jtt.bytecode.BC_ifge_2.test(1, 0)) { | |
4746 fail(runString); | |
4747 return; | |
4748 } | |
4749 // (1,1) == true | |
4750 runString = "(1,1)"; | |
4751 if (true != jtt.bytecode.BC_ifge_2.test(1, 1)) { | |
4752 fail(runString); | |
4753 return; | |
4754 } | |
4755 // (0,-100) == true | |
4756 runString = "(0,-100)"; | |
4757 if (true != jtt.bytecode.BC_ifge_2.test(0, -100)) { | |
4758 fail(runString); | |
4759 return; | |
4760 } | |
4761 // (-1,0) == false | |
4762 runString = "(-1,0)"; | |
4763 if (false != jtt.bytecode.BC_ifge_2.test(-1, 0)) { | |
4764 fail(runString); | |
4765 return; | |
4766 } | |
4767 // (-12,-12) == true | |
4768 runString = "(-12,-12)"; | |
4769 if (true != jtt.bytecode.BC_ifge_2.test(-12, -12)) { | |
4770 fail(runString); | |
4771 return; | |
4772 } | |
4773 } catch (Throwable t) { | |
4774 fail(runString, t); | |
4775 return; | |
4776 } | |
4777 pass(); | |
4778 } | |
4779 | |
4780 static void jtt_bytecode_BC_ifge_3() { | |
4781 begin("jtt.bytecode.BC_ifge_3"); | |
4782 String runString = null; | |
4783 try { | |
4784 // (0,1) == true | |
4785 runString = "(0,1)"; | |
4786 if (true != jtt.bytecode.BC_ifge_3.test(0, 1)) { | |
4787 fail(runString); | |
4788 return; | |
4789 } | |
4790 // (1,0) == false | |
4791 runString = "(1,0)"; | |
4792 if (false != jtt.bytecode.BC_ifge_3.test(1, 0)) { | |
4793 fail(runString); | |
4794 return; | |
4795 } | |
4796 // (1,1) == false | |
4797 runString = "(1,1)"; | |
4798 if (false != jtt.bytecode.BC_ifge_3.test(1, 1)) { | |
4799 fail(runString); | |
4800 return; | |
4801 } | |
4802 // (0,-100) == false | |
4803 runString = "(0,-100)"; | |
4804 if (false != jtt.bytecode.BC_ifge_3.test(0, -100)) { | |
4805 fail(runString); | |
4806 return; | |
4807 } | |
4808 // (-1,0) == true | |
4809 runString = "(-1,0)"; | |
4810 if (true != jtt.bytecode.BC_ifge_3.test(-1, 0)) { | |
4811 fail(runString); | |
4812 return; | |
4813 } | |
4814 // (-12,-12) == false | |
4815 runString = "(-12,-12)"; | |
4816 if (false != jtt.bytecode.BC_ifge_3.test(-12, -12)) { | |
4817 fail(runString); | |
4818 return; | |
4819 } | |
4820 } catch (Throwable t) { | |
4821 fail(runString, t); | |
4822 return; | |
4823 } | |
4824 pass(); | |
4825 } | |
4826 | |
4827 static void jtt_bytecode_BC_ifgt() { | |
4828 begin("jtt.bytecode.BC_ifgt"); | |
4829 String runString = null; | |
4830 try { | |
4831 // (0) == -2 | |
4832 runString = "(0)"; | |
4833 if (-2 != jtt.bytecode.BC_ifgt.test(0)) { | |
4834 fail(runString); | |
4835 return; | |
4836 } | |
4837 // (1) == 2 | |
4838 runString = "(1)"; | |
4839 if (2 != jtt.bytecode.BC_ifgt.test(1)) { | |
4840 fail(runString); | |
4841 return; | |
4842 } | |
4843 } catch (Throwable t) { | |
4844 fail(runString, t); | |
4845 return; | |
4846 } | |
4847 pass(); | |
4848 } | |
4849 | |
4850 static void jtt_bytecode_BC_ificmplt1() { | |
4851 begin("jtt.bytecode.BC_ificmplt1"); | |
4852 String runString = null; | |
4853 try { | |
4854 // (0) == 12 | |
4855 runString = "(0)"; | |
4856 if (12 != jtt.bytecode.BC_ificmplt1.test(0)) { | |
4857 fail(runString); | |
4858 return; | |
4859 } | |
4860 // (1) == 13 | |
4861 runString = "(1)"; | |
4862 if (13 != jtt.bytecode.BC_ificmplt1.test(1)) { | |
4863 fail(runString); | |
4864 return; | |
4865 } | |
4866 // (2) == 13 | |
4867 runString = "(2)"; | |
4868 if (13 != jtt.bytecode.BC_ificmplt1.test(2)) { | |
4869 fail(runString); | |
4870 return; | |
4871 } | |
4872 } catch (Throwable t) { | |
4873 fail(runString, t); | |
4874 return; | |
4875 } | |
4876 pass(); | |
4877 } | |
4878 | |
4879 static void jtt_bytecode_BC_ificmplt2() { | |
4880 begin("jtt.bytecode.BC_ificmplt2"); | |
4881 String runString = null; | |
4882 try { | |
4883 // (0) == 12 | |
4884 runString = "(0)"; | |
4885 if (12 != jtt.bytecode.BC_ificmplt2.test(0)) { | |
4886 fail(runString); | |
4887 return; | |
4888 } | |
4889 // (1) == 12 | |
4890 runString = "(1)"; | |
4891 if (12 != jtt.bytecode.BC_ificmplt2.test(1)) { | |
4892 fail(runString); | |
4893 return; | |
4894 } | |
4895 // (2) == 13 | |
4896 runString = "(2)"; | |
4897 if (13 != jtt.bytecode.BC_ificmplt2.test(2)) { | |
4898 fail(runString); | |
4899 return; | |
4900 } | |
4901 } catch (Throwable t) { | |
4902 fail(runString, t); | |
4903 return; | |
4904 } | |
4905 pass(); | |
4906 } | |
4907 | |
4908 static void jtt_bytecode_BC_ificmpne1() { | |
4909 begin("jtt.bytecode.BC_ificmpne1"); | |
4910 String runString = null; | |
4911 try { | |
4912 // (0) == 13 | |
4913 runString = "(0)"; | |
4914 if (13 != jtt.bytecode.BC_ificmpne1.test(0)) { | |
4915 fail(runString); | |
4916 return; | |
4917 } | |
4918 // (1) == 12 | |
4919 runString = "(1)"; | |
4920 if (12 != jtt.bytecode.BC_ificmpne1.test(1)) { | |
4921 fail(runString); | |
4922 return; | |
4923 } | |
4924 // (2) == 13 | |
4925 runString = "(2)"; | |
4926 if (13 != jtt.bytecode.BC_ificmpne1.test(2)) { | |
4927 fail(runString); | |
4928 return; | |
4929 } | |
4930 } catch (Throwable t) { | |
4931 fail(runString, t); | |
4932 return; | |
4933 } | |
4934 pass(); | |
4935 } | |
4936 | |
4937 static void jtt_bytecode_BC_ificmpne2() { | |
4938 begin("jtt.bytecode.BC_ificmpne2"); | |
4939 String runString = null; | |
4940 try { | |
4941 // (0) == 13 | |
4942 runString = "(0)"; | |
4943 if (13 != jtt.bytecode.BC_ificmpne2.test(0)) { | |
4944 fail(runString); | |
4945 return; | |
4946 } | |
4947 // (1) == 12 | |
4948 runString = "(1)"; | |
4949 if (12 != jtt.bytecode.BC_ificmpne2.test(1)) { | |
4950 fail(runString); | |
4951 return; | |
4952 } | |
4953 // (2) == 13 | |
4954 runString = "(2)"; | |
4955 if (13 != jtt.bytecode.BC_ificmpne2.test(2)) { | |
4956 fail(runString); | |
4957 return; | |
4958 } | |
4959 } catch (Throwable t) { | |
4960 fail(runString, t); | |
4961 return; | |
4962 } | |
4963 pass(); | |
4964 } | |
4965 | |
4966 static void jtt_bytecode_BC_ifle() { | |
4967 begin("jtt.bytecode.BC_ifle"); | |
4968 String runString = null; | |
4969 try { | |
4970 // (0) == 2 | |
4971 runString = "(0)"; | |
4972 if (2 != jtt.bytecode.BC_ifle.test(0)) { | |
4973 fail(runString); | |
4974 return; | |
4975 } | |
4976 // (1) == -2 | |
4977 runString = "(1)"; | |
4978 if (-2 != jtt.bytecode.BC_ifle.test(1)) { | |
4979 fail(runString); | |
4980 return; | |
4981 } | |
4982 } catch (Throwable t) { | |
4983 fail(runString, t); | |
4984 return; | |
4985 } | |
4986 pass(); | |
4987 } | |
4988 | |
4989 static void jtt_bytecode_BC_iflt() { | |
4990 begin("jtt.bytecode.BC_iflt"); | |
4991 String runString = null; | |
4992 try { | |
4993 // (0) == -2 | |
4994 runString = "(0)"; | |
4995 if (-2 != jtt.bytecode.BC_iflt.test(0)) { | |
4996 fail(runString); | |
4997 return; | |
4998 } | |
4999 // (1) == -2 | |
5000 runString = "(1)"; | |
5001 if (-2 != jtt.bytecode.BC_iflt.test(1)) { | |
5002 fail(runString); | |
5003 return; | |
5004 } | |
5005 // (-1) == 2 | |
5006 runString = "(-1)"; | |
5007 if (2 != jtt.bytecode.BC_iflt.test(-1)) { | |
5008 fail(runString); | |
5009 return; | |
5010 } | |
5011 } catch (Throwable t) { | |
5012 fail(runString, t); | |
5013 return; | |
5014 } | |
5015 pass(); | |
5016 } | |
5017 | |
5018 static void jtt_bytecode_BC_ifne() { | |
5019 begin("jtt.bytecode.BC_ifne"); | |
5020 String runString = null; | |
5021 try { | |
5022 // (0) == -2 | |
5023 runString = "(0)"; | |
5024 if (-2 != jtt.bytecode.BC_ifne.test(0)) { | |
5025 fail(runString); | |
5026 return; | |
5027 } | |
5028 // (1) == 2 | |
5029 runString = "(1)"; | |
5030 if (2 != jtt.bytecode.BC_ifne.test(1)) { | |
5031 fail(runString); | |
5032 return; | |
5033 } | |
5034 } catch (Throwable t) { | |
5035 fail(runString, t); | |
5036 return; | |
5037 } | |
5038 pass(); | |
5039 } | |
5040 | |
5041 static void jtt_bytecode_BC_ifnonnull() { | |
5042 begin("jtt.bytecode.BC_ifnonnull"); | |
5043 String runString = null; | |
5044 try { | |
5045 // (null) == 2 | |
5046 runString = "(null)"; | |
5047 if (2 != jtt.bytecode.BC_ifnonnull.test(null)) { | |
5048 fail(runString); | |
5049 return; | |
5050 } | |
5051 // ("") == -2 | |
5052 runString = "(\"\")"; | |
5053 if (-2 != jtt.bytecode.BC_ifnonnull.test("")) { | |
5054 fail(runString); | |
5055 return; | |
5056 } | |
5057 } catch (Throwable t) { | |
5058 fail(runString, t); | |
5059 return; | |
5060 } | |
5061 pass(); | |
5062 } | |
5063 | |
5064 static void jtt_bytecode_BC_ifnonnull_2() { | |
5065 begin("jtt.bytecode.BC_ifnonnull_2"); | |
5066 String runString = null; | |
5067 try { | |
5068 // (null) == false | |
5069 runString = "(null)"; | |
5070 if (false != jtt.bytecode.BC_ifnonnull_2.test(null)) { | |
5071 fail(runString); | |
5072 return; | |
5073 } | |
5074 // ("") == true | |
5075 runString = "(\"\")"; | |
5076 if (true != jtt.bytecode.BC_ifnonnull_2.test("")) { | |
5077 fail(runString); | |
5078 return; | |
5079 } | |
5080 } catch (Throwable t) { | |
5081 fail(runString, t); | |
5082 return; | |
5083 } | |
5084 pass(); | |
5085 } | |
5086 | |
5087 static void jtt_bytecode_BC_ifnonnull_3() { | |
5088 begin("jtt.bytecode.BC_ifnonnull_3"); | |
5089 String runString = null; | |
5090 try { | |
5091 // (null) == 2 | |
5092 runString = "(null)"; | |
5093 if (2 != jtt.bytecode.BC_ifnonnull_3.test(null)) { | |
5094 fail(runString); | |
5095 return; | |
5096 } | |
5097 // ("") == 1 | |
5098 runString = "(\"\")"; | |
5099 if (1 != jtt.bytecode.BC_ifnonnull_3.test("")) { | |
5100 fail(runString); | |
5101 return; | |
5102 } | |
5103 } catch (Throwable t) { | |
5104 fail(runString, t); | |
5105 return; | |
5106 } | |
5107 pass(); | |
5108 } | |
5109 | |
5110 static void jtt_bytecode_BC_ifnull() { | |
5111 begin("jtt.bytecode.BC_ifnull"); | |
5112 String runString = null; | |
5113 try { | |
5114 // (null) == -2 | |
5115 runString = "(null)"; | |
5116 if (-2 != jtt.bytecode.BC_ifnull.test(null)) { | |
5117 fail(runString); | |
5118 return; | |
5119 } | |
5120 // ("") == 2 | |
5121 runString = "(\"\")"; | |
5122 if (2 != jtt.bytecode.BC_ifnull.test("")) { | |
5123 fail(runString); | |
5124 return; | |
5125 } | |
5126 } catch (Throwable t) { | |
5127 fail(runString, t); | |
5128 return; | |
5129 } | |
5130 pass(); | |
5131 } | |
5132 | |
5133 static void jtt_bytecode_BC_ifnull_2() { | |
5134 begin("jtt.bytecode.BC_ifnull_2"); | |
5135 String runString = null; | |
5136 try { | |
5137 // (null) == true | |
5138 runString = "(null)"; | |
5139 if (true != jtt.bytecode.BC_ifnull_2.test(null)) { | |
5140 fail(runString); | |
5141 return; | |
5142 } | |
5143 // ("") == false | |
5144 runString = "(\"\")"; | |
5145 if (false != jtt.bytecode.BC_ifnull_2.test("")) { | |
5146 fail(runString); | |
5147 return; | |
5148 } | |
5149 } catch (Throwable t) { | |
5150 fail(runString, t); | |
5151 return; | |
5152 } | |
5153 pass(); | |
5154 } | |
5155 | |
5156 static void jtt_bytecode_BC_ifnull_3() { | |
5157 begin("jtt.bytecode.BC_ifnull_3"); | |
5158 String runString = null; | |
5159 try { | |
5160 // (null) == 1 | |
5161 runString = "(null)"; | |
5162 if (1 != jtt.bytecode.BC_ifnull_3.test(null)) { | |
5163 fail(runString); | |
5164 return; | |
5165 } | |
5166 // ("") == 2 | |
5167 runString = "(\"\")"; | |
5168 if (2 != jtt.bytecode.BC_ifnull_3.test("")) { | |
5169 fail(runString); | |
5170 return; | |
5171 } | |
5172 } catch (Throwable t) { | |
5173 fail(runString, t); | |
5174 return; | |
5175 } | |
5176 pass(); | |
5177 } | |
5178 | |
5179 static void jtt_bytecode_BC_iinc_1() { | |
5180 begin("jtt.bytecode.BC_iinc_1"); | |
5181 String runString = null; | |
5182 try { | |
5183 // (1) == 2 | |
5184 runString = "(1)"; | |
5185 if (2 != jtt.bytecode.BC_iinc_1.test(1)) { | |
5186 fail(runString); | |
5187 return; | |
5188 } | |
5189 // (2) == 3 | |
5190 runString = "(2)"; | |
5191 if (3 != jtt.bytecode.BC_iinc_1.test(2)) { | |
5192 fail(runString); | |
5193 return; | |
5194 } | |
5195 // (4) == 5 | |
5196 runString = "(4)"; | |
5197 if (5 != jtt.bytecode.BC_iinc_1.test(4)) { | |
5198 fail(runString); | |
5199 return; | |
5200 } | |
5201 // (-1) == 0 | |
5202 runString = "(-1)"; | |
5203 if (0 != jtt.bytecode.BC_iinc_1.test(-1)) { | |
5204 fail(runString); | |
5205 return; | |
5206 } | |
5207 } catch (Throwable t) { | |
5208 fail(runString, t); | |
5209 return; | |
5210 } | |
5211 pass(); | |
5212 } | |
5213 | |
5214 static void jtt_bytecode_BC_iinc_2() { | |
5215 begin("jtt.bytecode.BC_iinc_2"); | |
5216 String runString = null; | |
5217 try { | |
5218 // (1) == 3 | |
5219 runString = "(1)"; | |
5220 if (3 != jtt.bytecode.BC_iinc_2.test(1)) { | |
5221 fail(runString); | |
5222 return; | |
5223 } | |
5224 // (2) == 4 | |
5225 runString = "(2)"; | |
5226 if (4 != jtt.bytecode.BC_iinc_2.test(2)) { | |
5227 fail(runString); | |
5228 return; | |
5229 } | |
5230 // (4) == 6 | |
5231 runString = "(4)"; | |
5232 if (6 != jtt.bytecode.BC_iinc_2.test(4)) { | |
5233 fail(runString); | |
5234 return; | |
5235 } | |
5236 // (-2) == 0 | |
5237 runString = "(-2)"; | |
5238 if (0 != jtt.bytecode.BC_iinc_2.test(-2)) { | |
5239 fail(runString); | |
5240 return; | |
5241 } | |
5242 } catch (Throwable t) { | |
5243 fail(runString, t); | |
5244 return; | |
5245 } | |
5246 pass(); | |
5247 } | |
5248 | |
5249 static void jtt_bytecode_BC_iinc_3() { | |
5250 begin("jtt.bytecode.BC_iinc_3"); | |
5251 String runString = null; | |
5252 try { | |
5253 // (1) == 52 | |
5254 runString = "(1)"; | |
5255 if (52 != jtt.bytecode.BC_iinc_3.test(1)) { | |
5256 fail(runString); | |
5257 return; | |
5258 } | |
5259 // (2) == 53 | |
5260 runString = "(2)"; | |
5261 if (53 != jtt.bytecode.BC_iinc_3.test(2)) { | |
5262 fail(runString); | |
5263 return; | |
5264 } | |
5265 // (4) == 55 | |
5266 runString = "(4)"; | |
5267 if (55 != jtt.bytecode.BC_iinc_3.test(4)) { | |
5268 fail(runString); | |
5269 return; | |
5270 } | |
5271 // (-1) == 50 | |
5272 runString = "(-1)"; | |
5273 if (50 != jtt.bytecode.BC_iinc_3.test(-1)) { | |
5274 fail(runString); | |
5275 return; | |
5276 } | |
5277 } catch (Throwable t) { | |
5278 fail(runString, t); | |
5279 return; | |
5280 } | |
5281 pass(); | |
5282 } | |
5283 | |
5284 static void jtt_bytecode_BC_iinc_4() { | |
5285 begin("jtt.bytecode.BC_iinc_4"); | |
5286 String runString = null; | |
5287 try { | |
5288 // (1) == 513 | |
5289 runString = "(1)"; | |
5290 if (513 != jtt.bytecode.BC_iinc_4.test(1)) { | |
5291 fail(runString); | |
5292 return; | |
5293 } | |
5294 // (2) == 514 | |
5295 runString = "(2)"; | |
5296 if (514 != jtt.bytecode.BC_iinc_4.test(2)) { | |
5297 fail(runString); | |
5298 return; | |
5299 } | |
5300 // (4) == 516 | |
5301 runString = "(4)"; | |
5302 if (516 != jtt.bytecode.BC_iinc_4.test(4)) { | |
5303 fail(runString); | |
5304 return; | |
5305 } | |
5306 // (-1) == 511 | |
5307 runString = "(-1)"; | |
5308 if (511 != jtt.bytecode.BC_iinc_4.test(-1)) { | |
5309 fail(runString); | |
5310 return; | |
5311 } | |
5312 } catch (Throwable t) { | |
5313 fail(runString, t); | |
5314 return; | |
5315 } | |
5316 pass(); | |
5317 } | |
5318 | |
5319 static void jtt_bytecode_BC_iload_0() { | |
5320 begin("jtt.bytecode.BC_iload_0"); | |
5321 String runString = null; | |
5322 try { | |
5323 // (0) == 0 | |
5324 runString = "(0)"; | |
5325 if (0 != jtt.bytecode.BC_iload_0.test(0)) { | |
5326 fail(runString); | |
5327 return; | |
5328 } | |
5329 // (-1) == -1 | |
5330 runString = "(-1)"; | |
5331 if (-1 != jtt.bytecode.BC_iload_0.test(-1)) { | |
5332 fail(runString); | |
5333 return; | |
5334 } | |
5335 // (2) == 2 | |
5336 runString = "(2)"; | |
5337 if (2 != jtt.bytecode.BC_iload_0.test(2)) { | |
5338 fail(runString); | |
5339 return; | |
5340 } | |
5341 // (1000345) == 1000345 | |
5342 runString = "(1000345)"; | |
5343 if (1000345 != jtt.bytecode.BC_iload_0.test(1000345)) { | |
5344 fail(runString); | |
5345 return; | |
5346 } | |
5347 } catch (Throwable t) { | |
5348 fail(runString, t); | |
5349 return; | |
5350 } | |
5351 pass(); | |
5352 } | |
5353 | |
5354 static void jtt_bytecode_BC_iload_0_1() { | |
5355 begin("jtt.bytecode.BC_iload_0_1"); | |
5356 String runString = null; | |
5357 try { | |
5358 // (0) == 1 | |
5359 runString = "(0)"; | |
5360 if (1 != jtt.bytecode.BC_iload_0_1.test(0)) { | |
5361 fail(runString); | |
5362 return; | |
5363 } | |
5364 // (-1) == 0 | |
5365 runString = "(-1)"; | |
5366 if (0 != jtt.bytecode.BC_iload_0_1.test(-1)) { | |
5367 fail(runString); | |
5368 return; | |
5369 } | |
5370 // (2) == 3 | |
5371 runString = "(2)"; | |
5372 if (3 != jtt.bytecode.BC_iload_0_1.test(2)) { | |
5373 fail(runString); | |
5374 return; | |
5375 } | |
5376 // (1000345) == 1000346 | |
5377 runString = "(1000345)"; | |
5378 if (1000346 != jtt.bytecode.BC_iload_0_1.test(1000345)) { | |
5379 fail(runString); | |
5380 return; | |
5381 } | |
5382 } catch (Throwable t) { | |
5383 fail(runString, t); | |
5384 return; | |
5385 } | |
5386 pass(); | |
5387 } | |
5388 | |
5389 static void jtt_bytecode_BC_iload_0_2() { | |
5390 begin("jtt.bytecode.BC_iload_0_2"); | |
5391 String runString = null; | |
5392 try { | |
5393 // (0) == 0 | |
5394 runString = "(0)"; | |
5395 if (0 != jtt.bytecode.BC_iload_0_2.test(0)) { | |
5396 fail(runString); | |
5397 return; | |
5398 } | |
5399 // (-1) == -1 | |
5400 runString = "(-1)"; | |
5401 if (-1 != jtt.bytecode.BC_iload_0_2.test(-1)) { | |
5402 fail(runString); | |
5403 return; | |
5404 } | |
5405 // (2) == 2 | |
5406 runString = "(2)"; | |
5407 if (2 != jtt.bytecode.BC_iload_0_2.test(2)) { | |
5408 fail(runString); | |
5409 return; | |
5410 } | |
5411 // (1000345) == 1000345 | |
5412 runString = "(1000345)"; | |
5413 if (1000345 != jtt.bytecode.BC_iload_0_2.test(1000345)) { | |
5414 fail(runString); | |
5415 return; | |
5416 } | |
5417 } catch (Throwable t) { | |
5418 fail(runString, t); | |
5419 return; | |
5420 } | |
5421 pass(); | |
5422 } | |
5423 | |
5424 static void jtt_bytecode_BC_iload_1() { | |
5425 begin("jtt.bytecode.BC_iload_1"); | |
5426 String runString = null; | |
5427 try { | |
5428 // (1,0) == 0 | |
5429 runString = "(1,0)"; | |
5430 if (0 != jtt.bytecode.BC_iload_1.test(1, 0)) { | |
5431 fail(runString); | |
5432 return; | |
5433 } | |
5434 // (1,-1) == -1 | |
5435 runString = "(1,-1)"; | |
5436 if (-1 != jtt.bytecode.BC_iload_1.test(1, -1)) { | |
5437 fail(runString); | |
5438 return; | |
5439 } | |
5440 // (1,2) == 2 | |
5441 runString = "(1,2)"; | |
5442 if (2 != jtt.bytecode.BC_iload_1.test(1, 2)) { | |
5443 fail(runString); | |
5444 return; | |
5445 } | |
5446 // (1,1000345) == 1000345 | |
5447 runString = "(1,1000345)"; | |
5448 if (1000345 != jtt.bytecode.BC_iload_1.test(1, 1000345)) { | |
5449 fail(runString); | |
5450 return; | |
5451 } | |
5452 } catch (Throwable t) { | |
5453 fail(runString, t); | |
5454 return; | |
5455 } | |
5456 pass(); | |
5457 } | |
5458 | |
5459 static void jtt_bytecode_BC_iload_1_1() { | |
5460 begin("jtt.bytecode.BC_iload_1_1"); | |
5461 String runString = null; | |
5462 try { | |
5463 // (0) == 0 | |
5464 runString = "(0)"; | |
5465 if (0 != jtt.bytecode.BC_iload_1_1.test(0)) { | |
5466 fail(runString); | |
5467 return; | |
5468 } | |
5469 // (-1) == -1 | |
5470 runString = "(-1)"; | |
5471 if (-1 != jtt.bytecode.BC_iload_1_1.test(-1)) { | |
5472 fail(runString); | |
5473 return; | |
5474 } | |
5475 // (2) == 2 | |
5476 runString = "(2)"; | |
5477 if (2 != jtt.bytecode.BC_iload_1_1.test(2)) { | |
5478 fail(runString); | |
5479 return; | |
5480 } | |
5481 // (1000345) == 1000345 | |
5482 runString = "(1000345)"; | |
5483 if (1000345 != jtt.bytecode.BC_iload_1_1.test(1000345)) { | |
5484 fail(runString); | |
5485 return; | |
5486 } | |
5487 } catch (Throwable t) { | |
5488 fail(runString, t); | |
5489 return; | |
5490 } | |
5491 pass(); | |
5492 } | |
5493 | |
5494 static void jtt_bytecode_BC_iload_2() { | |
5495 begin("jtt.bytecode.BC_iload_2"); | |
5496 String runString = null; | |
5497 try { | |
5498 // (1,1,0) == 0 | |
5499 runString = "(1,1,0)"; | |
5500 if (0 != jtt.bytecode.BC_iload_2.test(1, 1, 0)) { | |
5501 fail(runString); | |
5502 return; | |
5503 } | |
5504 // (1,1,-1) == -1 | |
5505 runString = "(1,1,-1)"; | |
5506 if (-1 != jtt.bytecode.BC_iload_2.test(1, 1, -1)) { | |
5507 fail(runString); | |
5508 return; | |
5509 } | |
5510 // (1,1,2) == 2 | |
5511 runString = "(1,1,2)"; | |
5512 if (2 != jtt.bytecode.BC_iload_2.test(1, 1, 2)) { | |
5513 fail(runString); | |
5514 return; | |
5515 } | |
5516 // (1,1,1000345) == 1000345 | |
5517 runString = "(1,1,1000345)"; | |
5518 if (1000345 != jtt.bytecode.BC_iload_2.test(1, 1, 1000345)) { | |
5519 fail(runString); | |
5520 return; | |
5521 } | |
5522 } catch (Throwable t) { | |
5523 fail(runString, t); | |
5524 return; | |
5525 } | |
5526 pass(); | |
5527 } | |
5528 | |
5529 static void jtt_bytecode_BC_iload_3() { | |
5530 begin("jtt.bytecode.BC_iload_3"); | |
5531 String runString = null; | |
5532 try { | |
5533 // (1,1,1,0) == 0 | |
5534 runString = "(1,1,1,0)"; | |
5535 if (0 != jtt.bytecode.BC_iload_3.test(1, 1, 1, 0)) { | |
5536 fail(runString); | |
5537 return; | |
5538 } | |
5539 // (1,1,1,-1) == -1 | |
5540 runString = "(1,1,1,-1)"; | |
5541 if (-1 != jtt.bytecode.BC_iload_3.test(1, 1, 1, -1)) { | |
5542 fail(runString); | |
5543 return; | |
5544 } | |
5545 // (1,1,1,2) == 2 | |
5546 runString = "(1,1,1,2)"; | |
5547 if (2 != jtt.bytecode.BC_iload_3.test(1, 1, 1, 2)) { | |
5548 fail(runString); | |
5549 return; | |
5550 } | |
5551 // (1,1,1,1000345) == 1000345 | |
5552 runString = "(1,1,1,1000345)"; | |
5553 if (1000345 != jtt.bytecode.BC_iload_3.test(1, 1, 1, 1000345)) { | |
5554 fail(runString); | |
5555 return; | |
5556 } | |
5557 } catch (Throwable t) { | |
5558 fail(runString, t); | |
5559 return; | |
5560 } | |
5561 pass(); | |
5562 } | |
5563 | |
5564 static void jtt_bytecode_BC_imul() { | |
5565 begin("jtt.bytecode.BC_imul"); | |
5566 String runString = null; | |
5567 try { | |
5568 // (1,2) == 2 | |
5569 runString = "(1,2)"; | |
5570 if (2 != jtt.bytecode.BC_imul.test(1, 2)) { | |
5571 fail(runString); | |
5572 return; | |
5573 } | |
5574 // (0,-1) == 0 | |
5575 runString = "(0,-1)"; | |
5576 if (0 != jtt.bytecode.BC_imul.test(0, -1)) { | |
5577 fail(runString); | |
5578 return; | |
5579 } | |
5580 // (33,67) == 2211 | |
5581 runString = "(33,67)"; | |
5582 if (2211 != jtt.bytecode.BC_imul.test(33, 67)) { | |
5583 fail(runString); | |
5584 return; | |
5585 } | |
5586 // (1,-1) == -1 | |
5587 runString = "(1,-1)"; | |
5588 if (-1 != jtt.bytecode.BC_imul.test(1, -1)) { | |
5589 fail(runString); | |
5590 return; | |
5591 } | |
5592 // (-2147483648,1) == -2147483648 | |
5593 runString = "(-2147483648,1)"; | |
5594 if (-2147483648 != jtt.bytecode.BC_imul.test(-2147483648, 1)) { | |
5595 fail(runString); | |
5596 return; | |
5597 } | |
5598 // (2147483647,-1) == -2147483647 | |
5599 runString = "(2147483647,-1)"; | |
5600 if (-2147483647 != jtt.bytecode.BC_imul.test(2147483647, -1)) { | |
5601 fail(runString); | |
5602 return; | |
5603 } | |
5604 // (-2147483648,-1) == -2147483648 | |
5605 runString = "(-2147483648,-1)"; | |
5606 if (-2147483648 != jtt.bytecode.BC_imul.test(-2147483648, -1)) { | |
5607 fail(runString); | |
5608 return; | |
5609 } | |
5610 } catch (Throwable t) { | |
5611 fail(runString, t); | |
5612 return; | |
5613 } | |
5614 pass(); | |
5615 } | |
5616 | |
5617 static void jtt_bytecode_BC_ineg() { | |
5618 begin("jtt.bytecode.BC_ineg"); | |
5619 String runString = null; | |
5620 try { | |
5621 // (0) == 0 | |
5622 runString = "(0)"; | |
5623 if (0 != jtt.bytecode.BC_ineg.test(0)) { | |
5624 fail(runString); | |
5625 return; | |
5626 } | |
5627 // (-1) == 1 | |
5628 runString = "(-1)"; | |
5629 if (1 != jtt.bytecode.BC_ineg.test(-1)) { | |
5630 fail(runString); | |
5631 return; | |
5632 } | |
5633 // (7263) == -7263 | |
5634 runString = "(7263)"; | |
5635 if (-7263 != jtt.bytecode.BC_ineg.test(7263)) { | |
5636 fail(runString); | |
5637 return; | |
5638 } | |
5639 // (-2147483648) == -2147483648 | |
5640 runString = "(-2147483648)"; | |
5641 if (-2147483648 != jtt.bytecode.BC_ineg.test(-2147483648)) { | |
5642 fail(runString); | |
5643 return; | |
5644 } | |
5645 } catch (Throwable t) { | |
5646 fail(runString, t); | |
5647 return; | |
5648 } | |
5649 pass(); | |
5650 } | |
5651 | |
5652 static void jtt_bytecode_BC_instanceof() { | |
5653 begin("jtt.bytecode.BC_instanceof"); | |
5654 String runString = null; | |
5655 try { | |
5656 // (0) == false | |
5657 runString = "(0)"; | |
5658 if (false != jtt.bytecode.BC_instanceof.test(0)) { | |
5659 fail(runString); | |
5660 return; | |
5661 } | |
5662 // (1) == false | |
5663 runString = "(1)"; | |
5664 if (false != jtt.bytecode.BC_instanceof.test(1)) { | |
5665 fail(runString); | |
5666 return; | |
5667 } | |
5668 // (2) == false | |
5669 runString = "(2)"; | |
5670 if (false != jtt.bytecode.BC_instanceof.test(2)) { | |
5671 fail(runString); | |
5672 return; | |
5673 } | |
5674 // (3) == false | |
5675 runString = "(3)"; | |
5676 if (false != jtt.bytecode.BC_instanceof.test(3)) { | |
5677 fail(runString); | |
5678 return; | |
5679 } | |
5680 // (4) == true | |
5681 runString = "(4)"; | |
5682 if (true != jtt.bytecode.BC_instanceof.test(4)) { | |
5683 fail(runString); | |
5684 return; | |
5685 } | |
5686 } catch (Throwable t) { | |
5687 fail(runString, t); | |
5688 return; | |
5689 } | |
5690 pass(); | |
5691 } | |
5692 | |
5693 static void jtt_bytecode_BC_invokeinterface() { | |
5694 begin("jtt.bytecode.BC_invokeinterface"); | |
5695 String runString = null; | |
5696 try { | |
5697 // (0) == 0 | |
5698 runString = "(0)"; | |
5699 if (0 != jtt.bytecode.BC_invokeinterface.test(0)) { | |
5700 fail(runString); | |
5701 return; | |
5702 } | |
5703 // (1) == 1 | |
5704 runString = "(1)"; | |
5705 if (1 != jtt.bytecode.BC_invokeinterface.test(1)) { | |
5706 fail(runString); | |
5707 return; | |
5708 } | |
5709 // (2) == 2 | |
5710 runString = "(2)"; | |
5711 if (2 != jtt.bytecode.BC_invokeinterface.test(2)) { | |
5712 fail(runString); | |
5713 return; | |
5714 } | |
5715 // (3) == 3 | |
5716 runString = "(3)"; | |
5717 if (3 != jtt.bytecode.BC_invokeinterface.test(3)) { | |
5718 fail(runString); | |
5719 return; | |
5720 } | |
5721 // (-4) == -4 | |
5722 runString = "(-4)"; | |
5723 if (-4 != jtt.bytecode.BC_invokeinterface.test(-4)) { | |
5724 fail(runString); | |
5725 return; | |
5726 } | |
5727 } catch (Throwable t) { | |
5728 fail(runString, t); | |
5729 return; | |
5730 } | |
5731 pass(); | |
5732 } | |
5733 | |
5734 static void jtt_bytecode_BC_invokespecial() { | |
5735 begin("jtt.bytecode.BC_invokespecial"); | |
5736 String runString = null; | |
5737 try { | |
5738 // (0) == 0 | |
5739 runString = "(0)"; | |
5740 if (0 != jtt.bytecode.BC_invokespecial.test(0)) { | |
5741 fail(runString); | |
5742 return; | |
5743 } | |
5744 // (1) == 1 | |
5745 runString = "(1)"; | |
5746 if (1 != jtt.bytecode.BC_invokespecial.test(1)) { | |
5747 fail(runString); | |
5748 return; | |
5749 } | |
5750 // (2) == 2 | |
5751 runString = "(2)"; | |
5752 if (2 != jtt.bytecode.BC_invokespecial.test(2)) { | |
5753 fail(runString); | |
5754 return; | |
5755 } | |
5756 // (3) == 3 | |
5757 runString = "(3)"; | |
5758 if (3 != jtt.bytecode.BC_invokespecial.test(3)) { | |
5759 fail(runString); | |
5760 return; | |
5761 } | |
5762 // (-4) == -4 | |
5763 runString = "(-4)"; | |
5764 if (-4 != jtt.bytecode.BC_invokespecial.test(-4)) { | |
5765 fail(runString); | |
5766 return; | |
5767 } | |
5768 } catch (Throwable t) { | |
5769 fail(runString, t); | |
5770 return; | |
5771 } | |
5772 pass(); | |
5773 } | |
5774 | |
5775 static void jtt_bytecode_BC_invokespecial2() { | |
5776 begin("jtt.bytecode.BC_invokespecial2"); | |
5777 String runString = null; | |
5778 try { | |
5779 // (0) == 7 | |
5780 runString = "(0)"; | |
5781 if (7 != jtt.bytecode.BC_invokespecial2.test(0)) { | |
5782 fail(runString); | |
5783 return; | |
5784 } | |
5785 // (1) == 8 | |
5786 runString = "(1)"; | |
5787 if (8 != jtt.bytecode.BC_invokespecial2.test(1)) { | |
5788 fail(runString); | |
5789 return; | |
5790 } | |
5791 // (2) == 9 | |
5792 runString = "(2)"; | |
5793 if (9 != jtt.bytecode.BC_invokespecial2.test(2)) { | |
5794 fail(runString); | |
5795 return; | |
5796 } | |
5797 // (3) == 10 | |
5798 runString = "(3)"; | |
5799 if (10 != jtt.bytecode.BC_invokespecial2.test(3)) { | |
5800 fail(runString); | |
5801 return; | |
5802 } | |
5803 // (-4) == 3 | |
5804 runString = "(-4)"; | |
5805 if (3 != jtt.bytecode.BC_invokespecial2.test(-4)) { | |
5806 fail(runString); | |
5807 return; | |
5808 } | |
5809 } catch (Throwable t) { | |
5810 fail(runString, t); | |
5811 return; | |
5812 } | |
5813 pass(); | |
5814 } | |
5815 | |
5816 static void jtt_bytecode_BC_invokestatic() { | |
5817 begin("jtt.bytecode.BC_invokestatic"); | |
5818 String runString = null; | |
5819 try { | |
5820 // (0) == 0 | |
5821 runString = "(0)"; | |
5822 if (0 != jtt.bytecode.BC_invokestatic.test(0)) { | |
5823 fail(runString); | |
5824 return; | |
5825 } | |
5826 // (1) == 1 | |
5827 runString = "(1)"; | |
5828 if (1 != jtt.bytecode.BC_invokestatic.test(1)) { | |
5829 fail(runString); | |
5830 return; | |
5831 } | |
5832 // (2) == 2 | |
5833 runString = "(2)"; | |
5834 if (2 != jtt.bytecode.BC_invokestatic.test(2)) { | |
5835 fail(runString); | |
5836 return; | |
5837 } | |
5838 // (3) == 3 | |
5839 runString = "(3)"; | |
5840 if (3 != jtt.bytecode.BC_invokestatic.test(3)) { | |
5841 fail(runString); | |
5842 return; | |
5843 } | |
5844 // (-4) == -4 | |
5845 runString = "(-4)"; | |
5846 if (-4 != jtt.bytecode.BC_invokestatic.test(-4)) { | |
5847 fail(runString); | |
5848 return; | |
5849 } | |
5850 } catch (Throwable t) { | |
5851 fail(runString, t); | |
5852 return; | |
5853 } | |
5854 pass(); | |
5855 } | |
5856 | |
5857 static void jtt_bytecode_BC_invokevirtual() { | |
5858 begin("jtt.bytecode.BC_invokevirtual"); | |
5859 String runString = null; | |
5860 try { | |
5861 // (0) == 0 | |
5862 runString = "(0)"; | |
5863 if (0 != jtt.bytecode.BC_invokevirtual.test(0)) { | |
5864 fail(runString); | |
5865 return; | |
5866 } | |
5867 // (1) == 1 | |
5868 runString = "(1)"; | |
5869 if (1 != jtt.bytecode.BC_invokevirtual.test(1)) { | |
5870 fail(runString); | |
5871 return; | |
5872 } | |
5873 // (2) == 2 | |
5874 runString = "(2)"; | |
5875 if (2 != jtt.bytecode.BC_invokevirtual.test(2)) { | |
5876 fail(runString); | |
5877 return; | |
5878 } | |
5879 // (3) == 3 | |
5880 runString = "(3)"; | |
5881 if (3 != jtt.bytecode.BC_invokevirtual.test(3)) { | |
5882 fail(runString); | |
5883 return; | |
5884 } | |
5885 // (-4) == -4 | |
5886 runString = "(-4)"; | |
5887 if (-4 != jtt.bytecode.BC_invokevirtual.test(-4)) { | |
5888 fail(runString); | |
5889 return; | |
5890 } | |
5891 } catch (Throwable t) { | |
5892 fail(runString, t); | |
5893 return; | |
5894 } | |
5895 pass(); | |
5896 } | |
5897 | |
5898 static void jtt_bytecode_BC_ior() { | |
5899 begin("jtt.bytecode.BC_ior"); | |
5900 String runString = null; | |
5901 try { | |
5902 // (1,2) == 3 | |
5903 runString = "(1,2)"; | |
5904 if (3 != jtt.bytecode.BC_ior.test(1, 2)) { | |
5905 fail(runString); | |
5906 return; | |
5907 } | |
5908 // (0,-1) == -1 | |
5909 runString = "(0,-1)"; | |
5910 if (-1 != jtt.bytecode.BC_ior.test(0, -1)) { | |
5911 fail(runString); | |
5912 return; | |
5913 } | |
5914 // (31,63) == 63 | |
5915 runString = "(31,63)"; | |
5916 if (63 != jtt.bytecode.BC_ior.test(31, 63)) { | |
5917 fail(runString); | |
5918 return; | |
5919 } | |
5920 // (6,4) == 6 | |
5921 runString = "(6,4)"; | |
5922 if (6 != jtt.bytecode.BC_ior.test(6, 4)) { | |
5923 fail(runString); | |
5924 return; | |
5925 } | |
5926 // (-2147483648,1) == -2147483647 | |
5927 runString = "(-2147483648,1)"; | |
5928 if (-2147483647 != jtt.bytecode.BC_ior.test(-2147483648, 1)) { | |
5929 fail(runString); | |
5930 return; | |
5931 } | |
5932 } catch (Throwable t) { | |
5933 fail(runString, t); | |
5934 return; | |
5935 } | |
5936 pass(); | |
5937 } | |
5938 | |
5939 static void jtt_bytecode_BC_irem() { | |
5940 begin("jtt.bytecode.BC_irem"); | |
5941 String runString = null; | |
5942 try { | |
5943 // (1,2) == 1 | |
5944 runString = "(1,2)"; | |
5945 if (1 != jtt.bytecode.BC_irem.test(1, 2)) { | |
5946 fail(runString); | |
5947 return; | |
5948 } | |
5949 // (2,-1) == 0 | |
5950 runString = "(2,-1)"; | |
5951 if (0 != jtt.bytecode.BC_irem.test(2, -1)) { | |
5952 fail(runString); | |
5953 return; | |
5954 } | |
5955 // (256,4) == 0 | |
5956 runString = "(256,4)"; | |
5957 if (0 != jtt.bytecode.BC_irem.test(256, 4)) { | |
5958 fail(runString); | |
5959 return; | |
5960 } | |
5961 // (135,7) == 2 | |
5962 runString = "(135,7)"; | |
5963 if (2 != jtt.bytecode.BC_irem.test(135, 7)) { | |
5964 fail(runString); | |
5965 return; | |
5966 } | |
5967 } catch (Throwable t) { | |
5968 fail(runString, t); | |
5969 return; | |
5970 } | |
5971 pass(); | |
5972 } | |
5973 | |
5974 static void jtt_bytecode_BC_irem2() { | |
5975 begin("jtt.bytecode.BC_irem2"); | |
5976 String runString = null; | |
5977 try { | |
5978 // (-2147483648,-1) == 0 | |
5979 runString = "(-2147483648,-1)"; | |
5980 if (0 != jtt.bytecode.BC_irem2.test(-2147483648, -1)) { | |
5981 fail(runString); | |
5982 return; | |
5983 } | |
5984 // (-2147483648,1) == 0 | |
5985 runString = "(-2147483648,1)"; | |
5986 if (0 != jtt.bytecode.BC_irem2.test(-2147483648, 1)) { | |
5987 fail(runString); | |
5988 return; | |
5989 } | |
5990 } catch (Throwable t) { | |
5991 fail(runString, t); | |
5992 return; | |
5993 } | |
5994 pass(); | |
5995 } | |
5996 | |
5997 static void jtt_bytecode_BC_ireturn() { | |
5998 begin("jtt.bytecode.BC_ireturn"); | |
5999 String runString = null; | |
6000 try { | |
6001 // (0) == 0 | |
6002 runString = "(0)"; | |
6003 if (0 != jtt.bytecode.BC_ireturn.test(0)) { | |
6004 fail(runString); | |
6005 return; | |
6006 } | |
6007 // (1) == 1 | |
6008 runString = "(1)"; | |
6009 if (1 != jtt.bytecode.BC_ireturn.test(1)) { | |
6010 fail(runString); | |
6011 return; | |
6012 } | |
6013 // (-1) == -1 | |
6014 runString = "(-1)"; | |
6015 if (-1 != jtt.bytecode.BC_ireturn.test(-1)) { | |
6016 fail(runString); | |
6017 return; | |
6018 } | |
6019 // (256) == 256 | |
6020 runString = "(256)"; | |
6021 if (256 != jtt.bytecode.BC_ireturn.test(256)) { | |
6022 fail(runString); | |
6023 return; | |
6024 } | |
6025 } catch (Throwable t) { | |
6026 fail(runString, t); | |
6027 return; | |
6028 } | |
6029 pass(); | |
6030 } | |
6031 | |
6032 static void jtt_bytecode_BC_ishl() { | |
6033 begin("jtt.bytecode.BC_ishl"); | |
6034 String runString = null; | |
6035 try { | |
6036 // (1,2) == 4 | |
6037 runString = "(1,2)"; | |
6038 if (4 != jtt.bytecode.BC_ishl.test(1, 2)) { | |
6039 fail(runString); | |
6040 return; | |
6041 } | |
6042 // (0,-1) == 0 | |
6043 runString = "(0,-1)"; | |
6044 if (0 != jtt.bytecode.BC_ishl.test(0, -1)) { | |
6045 fail(runString); | |
6046 return; | |
6047 } | |
6048 // (31,1) == 62 | |
6049 runString = "(31,1)"; | |
6050 if (62 != jtt.bytecode.BC_ishl.test(31, 1)) { | |
6051 fail(runString); | |
6052 return; | |
6053 } | |
6054 // (6,4) == 96 | |
6055 runString = "(6,4)"; | |
6056 if (96 != jtt.bytecode.BC_ishl.test(6, 4)) { | |
6057 fail(runString); | |
6058 return; | |
6059 } | |
6060 // (-2147483648,1) == 0 | |
6061 runString = "(-2147483648,1)"; | |
6062 if (0 != jtt.bytecode.BC_ishl.test(-2147483648, 1)) { | |
6063 fail(runString); | |
6064 return; | |
6065 } | |
6066 } catch (Throwable t) { | |
6067 fail(runString, t); | |
6068 return; | |
6069 } | |
6070 pass(); | |
6071 } | |
6072 | |
6073 static void jtt_bytecode_BC_ishr() { | |
6074 begin("jtt.bytecode.BC_ishr"); | |
6075 String runString = null; | |
6076 try { | |
6077 // (1,2) == 0 | |
6078 runString = "(1,2)"; | |
6079 if (0 != jtt.bytecode.BC_ishr.test(1, 2)) { | |
6080 fail(runString); | |
6081 return; | |
6082 } | |
6083 // (67,2) == 16 | |
6084 runString = "(67,2)"; | |
6085 if (16 != jtt.bytecode.BC_ishr.test(67, 2)) { | |
6086 fail(runString); | |
6087 return; | |
6088 } | |
6089 // (31,1) == 15 | |
6090 runString = "(31,1)"; | |
6091 if (15 != jtt.bytecode.BC_ishr.test(31, 1)) { | |
6092 fail(runString); | |
6093 return; | |
6094 } | |
6095 // (6,4) == 0 | |
6096 runString = "(6,4)"; | |
6097 if (0 != jtt.bytecode.BC_ishr.test(6, 4)) { | |
6098 fail(runString); | |
6099 return; | |
6100 } | |
6101 // (-2147483648,16) == -32768 | |
6102 runString = "(-2147483648,16)"; | |
6103 if (-32768 != jtt.bytecode.BC_ishr.test(-2147483648, 16)) { | |
6104 fail(runString); | |
6105 return; | |
6106 } | |
6107 } catch (Throwable t) { | |
6108 fail(runString, t); | |
6109 return; | |
6110 } | |
6111 pass(); | |
6112 } | |
6113 | |
6114 static void jtt_bytecode_BC_isub() { | |
6115 begin("jtt.bytecode.BC_isub"); | |
6116 String runString = null; | |
6117 try { | |
6118 // (1,-2) == 3 | |
6119 runString = "(1,-2)"; | |
6120 if (3 != jtt.bytecode.BC_isub.test(1, -2)) { | |
6121 fail(runString); | |
6122 return; | |
6123 } | |
6124 // (0,1) == -1 | |
6125 runString = "(0,1)"; | |
6126 if (-1 != jtt.bytecode.BC_isub.test(0, 1)) { | |
6127 fail(runString); | |
6128 return; | |
6129 } | |
6130 // (33,-67) == 100 | |
6131 runString = "(33,-67)"; | |
6132 if (100 != jtt.bytecode.BC_isub.test(33, -67)) { | |
6133 fail(runString); | |
6134 return; | |
6135 } | |
6136 // (1,1) == 0 | |
6137 runString = "(1,1)"; | |
6138 if (0 != jtt.bytecode.BC_isub.test(1, 1)) { | |
6139 fail(runString); | |
6140 return; | |
6141 } | |
6142 // (-2147483648,-1) == -2147483647 | |
6143 runString = "(-2147483648,-1)"; | |
6144 if (-2147483647 != jtt.bytecode.BC_isub.test(-2147483648, -1)) { | |
6145 fail(runString); | |
6146 return; | |
6147 } | |
6148 // (2147483647,-1) == -2147483648 | |
6149 runString = "(2147483647,-1)"; | |
6150 if (-2147483648 != jtt.bytecode.BC_isub.test(2147483647, -1)) { | |
6151 fail(runString); | |
6152 return; | |
6153 } | |
6154 // (-2147483647,2) == 2147483647 | |
6155 runString = "(-2147483647,2)"; | |
6156 if (2147483647 != jtt.bytecode.BC_isub.test(-2147483647, 2)) { | |
6157 fail(runString); | |
6158 return; | |
6159 } | |
6160 } catch (Throwable t) { | |
6161 fail(runString, t); | |
6162 return; | |
6163 } | |
6164 pass(); | |
6165 } | |
6166 | |
6167 static void jtt_bytecode_BC_iushr() { | |
6168 begin("jtt.bytecode.BC_iushr"); | |
6169 String runString = null; | |
6170 try { | |
6171 // (1,2) == 0 | |
6172 runString = "(1,2)"; | |
6173 if (0 != jtt.bytecode.BC_iushr.test(1, 2)) { | |
6174 fail(runString); | |
6175 return; | |
6176 } | |
6177 // (67,2) == 16 | |
6178 runString = "(67,2)"; | |
6179 if (16 != jtt.bytecode.BC_iushr.test(67, 2)) { | |
6180 fail(runString); | |
6181 return; | |
6182 } | |
6183 // (31,1) == 15 | |
6184 runString = "(31,1)"; | |
6185 if (15 != jtt.bytecode.BC_iushr.test(31, 1)) { | |
6186 fail(runString); | |
6187 return; | |
6188 } | |
6189 // (6,4) == 0 | |
6190 runString = "(6,4)"; | |
6191 if (0 != jtt.bytecode.BC_iushr.test(6, 4)) { | |
6192 fail(runString); | |
6193 return; | |
6194 } | |
6195 // (-2147483648,16) == 32768 | |
6196 runString = "(-2147483648,16)"; | |
6197 if (32768 != jtt.bytecode.BC_iushr.test(-2147483648, 16)) { | |
6198 fail(runString); | |
6199 return; | |
6200 } | |
6201 } catch (Throwable t) { | |
6202 fail(runString, t); | |
6203 return; | |
6204 } | |
6205 pass(); | |
6206 } | |
6207 | |
6208 static void jtt_bytecode_BC_ixor() { | |
6209 begin("jtt.bytecode.BC_ixor"); | |
6210 String runString = null; | |
6211 try { | |
6212 // (1,2) == 3 | |
6213 runString = "(1,2)"; | |
6214 if (3 != jtt.bytecode.BC_ixor.test(1, 2)) { | |
6215 fail(runString); | |
6216 return; | |
6217 } | |
6218 // (0,-1) == -1 | |
6219 runString = "(0,-1)"; | |
6220 if (-1 != jtt.bytecode.BC_ixor.test(0, -1)) { | |
6221 fail(runString); | |
6222 return; | |
6223 } | |
6224 // (31,63) == 32 | |
6225 runString = "(31,63)"; | |
6226 if (32 != jtt.bytecode.BC_ixor.test(31, 63)) { | |
6227 fail(runString); | |
6228 return; | |
6229 } | |
6230 // (6,4) == 2 | |
6231 runString = "(6,4)"; | |
6232 if (2 != jtt.bytecode.BC_ixor.test(6, 4)) { | |
6233 fail(runString); | |
6234 return; | |
6235 } | |
6236 // (-2147483648,1) == -2147483647 | |
6237 runString = "(-2147483648,1)"; | |
6238 if (-2147483647 != jtt.bytecode.BC_ixor.test(-2147483648, 1)) { | |
6239 fail(runString); | |
6240 return; | |
6241 } | |
6242 } catch (Throwable t) { | |
6243 fail(runString, t); | |
6244 return; | |
6245 } | |
6246 pass(); | |
6247 } | |
6248 | |
6249 static void jtt_bytecode_BC_l2d() { | |
6250 begin("jtt.bytecode.BC_l2d"); | |
6251 String runString = null; | |
6252 try { | |
6253 // (0) == 0.0 | |
6254 runString = "(0)"; | |
6255 if (0.0 != jtt.bytecode.BC_l2d.test(0L)) { | |
6256 fail(runString); | |
6257 return; | |
6258 } | |
6259 // (1) == 1.0 | |
6260 runString = "(1)"; | |
6261 if (1.0 != jtt.bytecode.BC_l2d.test(1L)) { | |
6262 fail(runString); | |
6263 return; | |
6264 } | |
6265 // (-74652389) == -7.4652389E7 | |
6266 runString = "(-74652389)"; | |
6267 if (-7.4652389E7 != jtt.bytecode.BC_l2d.test(-74652389L)) { | |
6268 fail(runString); | |
6269 return; | |
6270 } | |
6271 } catch (Throwable t) { | |
6272 fail(runString, t); | |
6273 return; | |
6274 } | |
6275 pass(); | |
6276 } | |
6277 | |
6278 static void jtt_bytecode_BC_l2f() { | |
6279 begin("jtt.bytecode.BC_l2f"); | |
6280 String runString = null; | |
6281 try { | |
6282 // (0) == 0.0 | |
6283 runString = "(0)"; | |
6284 if (0.0f != jtt.bytecode.BC_l2f.test(0L)) { | |
6285 fail(runString); | |
6286 return; | |
6287 } | |
6288 // (1) == 1.0 | |
6289 runString = "(1)"; | |
6290 if (1.0f != jtt.bytecode.BC_l2f.test(1L)) { | |
6291 fail(runString); | |
6292 return; | |
6293 } | |
6294 // (-74652389) == -7.4652392E7 | |
6295 runString = "(-74652389)"; | |
6296 if (-7.4652392E7f != jtt.bytecode.BC_l2f.test(-74652389L)) { | |
6297 fail(runString); | |
6298 return; | |
6299 } | |
6300 } catch (Throwable t) { | |
6301 fail(runString, t); | |
6302 return; | |
6303 } | |
6304 pass(); | |
6305 } | |
6306 | |
6307 static void jtt_bytecode_BC_l2i() { | |
6308 begin("jtt.bytecode.BC_l2i"); | |
6309 String runString = null; | |
6310 try { | |
6311 // (1) == 1 | |
6312 runString = "(1)"; | |
6313 if (1 != jtt.bytecode.BC_l2i.test(1L)) { | |
6314 fail(runString); | |
6315 return; | |
6316 } | |
6317 // (2) == 2 | |
6318 runString = "(2)"; | |
6319 if (2 != jtt.bytecode.BC_l2i.test(2L)) { | |
6320 fail(runString); | |
6321 return; | |
6322 } | |
6323 // (3) == 3 | |
6324 runString = "(3)"; | |
6325 if (3 != jtt.bytecode.BC_l2i.test(3L)) { | |
6326 fail(runString); | |
6327 return; | |
6328 } | |
6329 // (-1) == -1 | |
6330 runString = "(-1)"; | |
6331 if (-1 != jtt.bytecode.BC_l2i.test(-1L)) { | |
6332 fail(runString); | |
6333 return; | |
6334 } | |
6335 // (-2147483647) == -2147483647 | |
6336 runString = "(-2147483647)"; | |
6337 if (-2147483647 != jtt.bytecode.BC_l2i.test(-2147483647L)) { | |
6338 fail(runString); | |
6339 return; | |
6340 } | |
6341 // (-2147483648) == -2147483648 | |
6342 runString = "(-2147483648)"; | |
6343 if (-2147483648 != jtt.bytecode.BC_l2i.test(-2147483648L)) { | |
6344 fail(runString); | |
6345 return; | |
6346 } | |
6347 // (2147483647) == 2147483647 | |
6348 runString = "(2147483647)"; | |
6349 if (2147483647 != jtt.bytecode.BC_l2i.test(2147483647L)) { | |
6350 fail(runString); | |
6351 return; | |
6352 } | |
6353 } catch (Throwable t) { | |
6354 fail(runString, t); | |
6355 return; | |
6356 } | |
6357 pass(); | |
6358 } | |
6359 | |
6360 static void jtt_bytecode_BC_ladd() { | |
6361 begin("jtt.bytecode.BC_ladd"); | |
6362 String runString = null; | |
6363 try { | |
6364 // (1,2) == 3 | |
6365 runString = "(1,2)"; | |
6366 if (3L != jtt.bytecode.BC_ladd.test(1L, 2L)) { | |
6367 fail(runString); | |
6368 return; | |
6369 } | |
6370 // (0,-1) == -1 | |
6371 runString = "(0,-1)"; | |
6372 if (-1L != jtt.bytecode.BC_ladd.test(0L, -1L)) { | |
6373 fail(runString); | |
6374 return; | |
6375 } | |
6376 // (33,67) == 100 | |
6377 runString = "(33,67)"; | |
6378 if (100L != jtt.bytecode.BC_ladd.test(33L, 67L)) { | |
6379 fail(runString); | |
6380 return; | |
6381 } | |
6382 // (1,-1) == 0 | |
6383 runString = "(1,-1)"; | |
6384 if (0L != jtt.bytecode.BC_ladd.test(1L, -1L)) { | |
6385 fail(runString); | |
6386 return; | |
6387 } | |
6388 // (-2147483648,1) == -2147483647 | |
6389 runString = "(-2147483648,1)"; | |
6390 if (-2147483647L != jtt.bytecode.BC_ladd.test(-2147483648L, 1L)) { | |
6391 fail(runString); | |
6392 return; | |
6393 } | |
6394 // (2147483647,1) == 2147483648 | |
6395 runString = "(2147483647,1)"; | |
6396 if (2147483648L != jtt.bytecode.BC_ladd.test(2147483647L, 1L)) { | |
6397 fail(runString); | |
6398 return; | |
6399 } | |
6400 } catch (Throwable t) { | |
6401 fail(runString, t); | |
6402 return; | |
6403 } | |
6404 pass(); | |
6405 } | |
6406 | |
6407 static void jtt_bytecode_BC_ladd2() { | |
6408 begin("jtt.bytecode.BC_ladd2"); | |
6409 String runString = null; | |
6410 try { | |
6411 // (1,2) == 3 | |
6412 runString = "(1,2)"; | |
6413 if (3L != jtt.bytecode.BC_ladd2.test(1, 2)) { | |
6414 fail(runString); | |
6415 return; | |
6416 } | |
6417 // (0,-1) == -1 | |
6418 runString = "(0,-1)"; | |
6419 if (-1L != jtt.bytecode.BC_ladd2.test(0, -1)) { | |
6420 fail(runString); | |
6421 return; | |
6422 } | |
6423 // (33,67) == 100 | |
6424 runString = "(33,67)"; | |
6425 if (100L != jtt.bytecode.BC_ladd2.test(33, 67)) { | |
6426 fail(runString); | |
6427 return; | |
6428 } | |
6429 // (1,-1) == 0 | |
6430 runString = "(1,-1)"; | |
6431 if (0L != jtt.bytecode.BC_ladd2.test(1, -1)) { | |
6432 fail(runString); | |
6433 return; | |
6434 } | |
6435 // (-2147483648,1) == -2147483647 | |
6436 runString = "(-2147483648,1)"; | |
6437 if (-2147483647L != jtt.bytecode.BC_ladd2.test(-2147483648, 1)) { | |
6438 fail(runString); | |
6439 return; | |
6440 } | |
6441 // (2147483647,1) == 2147483648 | |
6442 runString = "(2147483647,1)"; | |
6443 if (2147483648L != jtt.bytecode.BC_ladd2.test(2147483647, 1)) { | |
6444 fail(runString); | |
6445 return; | |
6446 } | |
6447 } catch (Throwable t) { | |
6448 fail(runString, t); | |
6449 return; | |
6450 } | |
6451 pass(); | |
6452 } | |
6453 | |
6454 static void jtt_bytecode_BC_laload() { | |
6455 begin("jtt.bytecode.BC_laload"); | |
6456 String runString = null; | |
6457 try { | |
6458 // (0) == 0 | |
6459 runString = "(0)"; | |
6460 if (0L != jtt.bytecode.BC_laload.test(0)) { | |
6461 fail(runString); | |
6462 return; | |
6463 } | |
6464 // (1) == -1 | |
6465 runString = "(1)"; | |
6466 if (-1L != jtt.bytecode.BC_laload.test(1)) { | |
6467 fail(runString); | |
6468 return; | |
6469 } | |
6470 // (2) == 4 | |
6471 runString = "(2)"; | |
6472 if (4L != jtt.bytecode.BC_laload.test(2)) { | |
6473 fail(runString); | |
6474 return; | |
6475 } | |
6476 // (3) == 1000000000000 | |
6477 runString = "(3)"; | |
6478 if (1000000000000L != jtt.bytecode.BC_laload.test(3)) { | |
6479 fail(runString); | |
6480 return; | |
6481 } | |
6482 } catch (Throwable t) { | |
6483 fail(runString, t); | |
6484 return; | |
6485 } | |
6486 pass(); | |
6487 } | |
6488 | |
6489 static void jtt_bytecode_BC_land() { | |
6490 begin("jtt.bytecode.BC_land"); | |
6491 String runString = null; | |
6492 try { | |
6493 // (1,2) == 0 | |
6494 runString = "(1,2)"; | |
6495 if (0L != jtt.bytecode.BC_land.test(1L, 2L)) { | |
6496 fail(runString); | |
6497 return; | |
6498 } | |
6499 // (0,-1) == 0 | |
6500 runString = "(0,-1)"; | |
6501 if (0L != jtt.bytecode.BC_land.test(0L, -1L)) { | |
6502 fail(runString); | |
6503 return; | |
6504 } | |
6505 // (31,63) == 31 | |
6506 runString = "(31,63)"; | |
6507 if (31L != jtt.bytecode.BC_land.test(31L, 63L)) { | |
6508 fail(runString); | |
6509 return; | |
6510 } | |
6511 // (6,4) == 4 | |
6512 runString = "(6,4)"; | |
6513 if (4L != jtt.bytecode.BC_land.test(6L, 4L)) { | |
6514 fail(runString); | |
6515 return; | |
6516 } | |
6517 // (-2147483648,1) == 0 | |
6518 runString = "(-2147483648,1)"; | |
6519 if (0L != jtt.bytecode.BC_land.test(-2147483648L, 1L)) { | |
6520 fail(runString); | |
6521 return; | |
6522 } | |
6523 } catch (Throwable t) { | |
6524 fail(runString, t); | |
6525 return; | |
6526 } | |
6527 pass(); | |
6528 } | |
6529 | |
6530 static void jtt_bytecode_BC_lastore() { | |
6531 begin("jtt.bytecode.BC_lastore"); | |
6532 String runString = null; | |
6533 try { | |
6534 // (0,0) == 0 | |
6535 runString = "(0,0)"; | |
6536 if (0L != jtt.bytecode.BC_lastore.test(0, 0L)) { | |
6537 fail(runString); | |
6538 return; | |
6539 } | |
6540 // (1,-1) == -1 | |
6541 runString = "(1,-1)"; | |
6542 if (-1L != jtt.bytecode.BC_lastore.test(1, -1L)) { | |
6543 fail(runString); | |
6544 return; | |
6545 } | |
6546 // (2,11) == 11 | |
6547 runString = "(2,11)"; | |
6548 if (11L != jtt.bytecode.BC_lastore.test(2, 11L)) { | |
6549 fail(runString); | |
6550 return; | |
6551 } | |
6552 // (3,-14) == -14 | |
6553 runString = "(3,-14)"; | |
6554 if (-14L != jtt.bytecode.BC_lastore.test(3, -14L)) { | |
6555 fail(runString); | |
6556 return; | |
6557 } | |
6558 } catch (Throwable t) { | |
6559 fail(runString, t); | |
6560 return; | |
6561 } | |
6562 pass(); | |
6563 } | |
6564 | |
6565 static void jtt_bytecode_BC_lcmp() { | |
6566 begin("jtt.bytecode.BC_lcmp"); | |
6567 String runString = null; | |
6568 try { | |
6569 // (0,-1) == false | |
6570 runString = "(0,-1)"; | |
6571 if (false != jtt.bytecode.BC_lcmp.test(0L, -1L)) { | |
6572 fail(runString); | |
6573 return; | |
6574 } | |
6575 // (77,78) == true | |
6576 runString = "(77,78)"; | |
6577 if (true != jtt.bytecode.BC_lcmp.test(77L, 78L)) { | |
6578 fail(runString); | |
6579 return; | |
6580 } | |
6581 // (-1,0) == true | |
6582 runString = "(-1,0)"; | |
6583 if (true != jtt.bytecode.BC_lcmp.test(-1L, 0L)) { | |
6584 fail(runString); | |
6585 return; | |
6586 } | |
6587 } catch (Throwable t) { | |
6588 fail(runString, t); | |
6589 return; | |
6590 } | |
6591 pass(); | |
6592 } | |
6593 | |
6594 static void jtt_bytecode_BC_ldc_01() { | |
6595 begin("jtt.bytecode.BC_ldc_01"); | |
6596 String runString = null; | |
6597 try { | |
6598 // (0) == -123 | |
6599 runString = "(0)"; | |
6600 if (-123 != jtt.bytecode.BC_ldc_01.test(0)) { | |
6601 fail(runString); | |
6602 return; | |
6603 } | |
6604 } catch (Throwable t) { | |
6605 fail(runString, t); | |
6606 return; | |
6607 } | |
6608 pass(); | |
6609 } | |
6610 | |
6611 static void jtt_bytecode_BC_ldc_02() { | |
6612 begin("jtt.bytecode.BC_ldc_02"); | |
6613 String runString = null; | |
6614 try { | |
6615 // (0) == -2.4 | |
6616 runString = "(0)"; | |
6617 if (-2.4f != jtt.bytecode.BC_ldc_02.test(0)) { | |
6618 fail(runString); | |
6619 return; | |
6620 } | |
6621 } catch (Throwable t) { | |
6622 fail(runString, t); | |
6623 return; | |
6624 } | |
6625 pass(); | |
6626 } | |
6627 | |
6628 static void jtt_bytecode_BC_ldc_03() { | |
6629 begin("jtt.bytecode.BC_ldc_03"); | |
6630 String runString = null; | |
6631 try { | |
6632 // (0) == -123 | |
6633 runString = "(0)"; | |
6634 if (-123L != jtt.bytecode.BC_ldc_03.test(0)) { | |
6635 fail(runString); | |
6636 return; | |
6637 } | |
6638 } catch (Throwable t) { | |
6639 fail(runString, t); | |
6640 return; | |
6641 } | |
6642 pass(); | |
6643 } | |
6644 | |
6645 static void jtt_bytecode_BC_ldc_04() { | |
6646 begin("jtt.bytecode.BC_ldc_04"); | |
6647 String runString = null; | |
6648 try { | |
6649 // (0) == "xyz" | |
6650 runString = "(0)"; | |
6651 if (!"xyz".equals(jtt.bytecode.BC_ldc_04.test(0))) { | |
6652 fail(runString); | |
6653 return; | |
6654 } | |
6655 } catch (Throwable t) { | |
6656 fail(runString, t); | |
6657 return; | |
6658 } | |
6659 pass(); | |
6660 } | |
6661 | |
6662 static void jtt_bytecode_BC_ldc_05() { | |
6663 begin("jtt.bytecode.BC_ldc_05"); | |
6664 String runString = null; | |
6665 try { | |
6666 // (0) == -2.33 | |
6667 runString = "(0)"; | |
6668 if (-2.33 != jtt.bytecode.BC_ldc_05.test(0)) { | |
6669 fail(runString); | |
6670 return; | |
6671 } | |
6672 } catch (Throwable t) { | |
6673 fail(runString, t); | |
6674 return; | |
6675 } | |
6676 pass(); | |
6677 } | |
6678 | |
6679 static void jtt_bytecode_BC_ldc_06() { | |
6680 begin("jtt.bytecode.BC_ldc_06"); | |
6681 String runString = null; | |
6682 try { | |
6683 // (0) == "jtt.bytecode.BC_ldc_06" | |
6684 runString = "(0)"; | |
6685 if (!"jtt.bytecode.BC_ldc_06" | |
6686 .equals(jtt.bytecode.BC_ldc_06.test(0))) { | |
6687 fail(runString); | |
6688 return; | |
6689 } | |
6690 } catch (Throwable t) { | |
6691 fail(runString, t); | |
6692 return; | |
6693 } | |
6694 pass(); | |
6695 } | |
6696 | |
6697 static void jtt_bytecode_BC_ldiv() { | |
6698 begin("jtt.bytecode.BC_ldiv"); | |
6699 String runString = null; | |
6700 try { | |
6701 // (1,2) == 0 | |
6702 runString = "(1,2)"; | |
6703 if (0L != jtt.bytecode.BC_ldiv.test(1L, 2L)) { | |
6704 fail(runString); | |
6705 return; | |
6706 } | |
6707 // (2,-1) == -2 | |
6708 runString = "(2,-1)"; | |
6709 if (-2L != jtt.bytecode.BC_ldiv.test(2L, -1L)) { | |
6710 fail(runString); | |
6711 return; | |
6712 } | |
6713 // (256,4) == 64 | |
6714 runString = "(256,4)"; | |
6715 if (64L != jtt.bytecode.BC_ldiv.test(256L, 4L)) { | |
6716 fail(runString); | |
6717 return; | |
6718 } | |
6719 // (135,7) == 19 | |
6720 runString = "(135,7)"; | |
6721 if (19L != jtt.bytecode.BC_ldiv.test(135L, 7L)) { | |
6722 fail(runString); | |
6723 return; | |
6724 } | |
6725 } catch (Throwable t) { | |
6726 fail(runString, t); | |
6727 return; | |
6728 } | |
6729 pass(); | |
6730 } | |
6731 | |
6732 static void jtt_bytecode_BC_ldiv2() { | |
6733 begin("jtt.bytecode.BC_ldiv2"); | |
6734 String runString = null; | |
6735 try { | |
6736 // (-9223372036854775808,-1) == -9223372036854775808 | |
6737 runString = "(-9223372036854775808,-1)"; | |
6738 if (-9223372036854775808L != jtt.bytecode.BC_ldiv2.test( | |
6739 -9223372036854775808L, -1)) { | |
6740 fail(runString); | |
6741 return; | |
6742 } | |
6743 // (-9223372036854775808,1) == -9223372036854775808 | |
6744 runString = "(-9223372036854775808,1)"; | |
6745 if (-9223372036854775808L != jtt.bytecode.BC_ldiv2.test( | |
6746 -9223372036854775808L, 1)) { | |
6747 fail(runString); | |
6748 return; | |
6749 } | |
6750 } catch (Throwable t) { | |
6751 fail(runString, t); | |
6752 return; | |
6753 } | |
6754 pass(); | |
6755 } | |
6756 | |
6757 static void jtt_bytecode_BC_lload_0() { | |
6758 begin("jtt.bytecode.BC_lload_0"); | |
6759 String runString = null; | |
6760 try { | |
6761 // (1) == 1 | |
6762 runString = "(1)"; | |
6763 if (1L != jtt.bytecode.BC_lload_0.test(1L)) { | |
6764 fail(runString); | |
6765 return; | |
6766 } | |
6767 // (-3) == -3 | |
6768 runString = "(-3)"; | |
6769 if (-3L != jtt.bytecode.BC_lload_0.test(-3L)) { | |
6770 fail(runString); | |
6771 return; | |
6772 } | |
6773 // (10000) == 10000 | |
6774 runString = "(10000)"; | |
6775 if (10000L != jtt.bytecode.BC_lload_0.test(10000L)) { | |
6776 fail(runString); | |
6777 return; | |
6778 } | |
6779 } catch (Throwable t) { | |
6780 fail(runString, t); | |
6781 return; | |
6782 } | |
6783 pass(); | |
6784 } | |
6785 | |
6786 static void jtt_bytecode_BC_lload_01() { | |
6787 begin("jtt.bytecode.BC_lload_01"); | |
6788 String runString = null; | |
6789 try { | |
6790 // (1) == 0 | |
6791 runString = "(1)"; | |
6792 if (0L != jtt.bytecode.BC_lload_01.test(1)) { | |
6793 fail(runString); | |
6794 return; | |
6795 } | |
6796 // (-3) == 0 | |
6797 runString = "(-3)"; | |
6798 if (0L != jtt.bytecode.BC_lload_01.test(-3)) { | |
6799 fail(runString); | |
6800 return; | |
6801 } | |
6802 // (100) == 0 | |
6803 runString = "(100)"; | |
6804 if (0L != jtt.bytecode.BC_lload_01.test(100)) { | |
6805 fail(runString); | |
6806 return; | |
6807 } | |
6808 } catch (Throwable t) { | |
6809 fail(runString, t); | |
6810 return; | |
6811 } | |
6812 pass(); | |
6813 } | |
6814 | |
6815 static void jtt_bytecode_BC_lload_1() { | |
6816 begin("jtt.bytecode.BC_lload_1"); | |
6817 String runString = null; | |
6818 try { | |
6819 // (1,1) == 1 | |
6820 runString = "(1,1)"; | |
6821 if (1L != jtt.bytecode.BC_lload_1.test(1, 1L)) { | |
6822 fail(runString); | |
6823 return; | |
6824 } | |
6825 // (1,-3) == -3 | |
6826 runString = "(1,-3)"; | |
6827 if (-3L != jtt.bytecode.BC_lload_1.test(1, -3L)) { | |
6828 fail(runString); | |
6829 return; | |
6830 } | |
6831 // (1,10000) == 10000 | |
6832 runString = "(1,10000)"; | |
6833 if (10000L != jtt.bytecode.BC_lload_1.test(1, 10000L)) { | |
6834 fail(runString); | |
6835 return; | |
6836 } | |
6837 } catch (Throwable t) { | |
6838 fail(runString, t); | |
6839 return; | |
6840 } | |
6841 pass(); | |
6842 } | |
6843 | |
6844 static void jtt_bytecode_BC_lload_2() { | |
6845 begin("jtt.bytecode.BC_lload_2"); | |
6846 String runString = null; | |
6847 try { | |
6848 // (1,1,1) == 1 | |
6849 runString = "(1,1,1)"; | |
6850 if (1L != jtt.bytecode.BC_lload_2.test(1, 1, 1L)) { | |
6851 fail(runString); | |
6852 return; | |
6853 } | |
6854 // (1,1,-3) == -3 | |
6855 runString = "(1,1,-3)"; | |
6856 if (-3L != jtt.bytecode.BC_lload_2.test(1, 1, -3L)) { | |
6857 fail(runString); | |
6858 return; | |
6859 } | |
6860 // (1,1,10000) == 10000 | |
6861 runString = "(1,1,10000)"; | |
6862 if (10000L != jtt.bytecode.BC_lload_2.test(1, 1, 10000L)) { | |
6863 fail(runString); | |
6864 return; | |
6865 } | |
6866 } catch (Throwable t) { | |
6867 fail(runString, t); | |
6868 return; | |
6869 } | |
6870 pass(); | |
6871 } | |
6872 | |
6873 static void jtt_bytecode_BC_lload_3() { | |
6874 begin("jtt.bytecode.BC_lload_3"); | |
6875 String runString = null; | |
6876 try { | |
6877 // (1,1,1,1) == 1 | |
6878 runString = "(1,1,1,1)"; | |
6879 if (1L != jtt.bytecode.BC_lload_3.test(1, 1, 1, 1L)) { | |
6880 fail(runString); | |
6881 return; | |
6882 } | |
6883 // (1,1,1,-3) == -3 | |
6884 runString = "(1,1,1,-3)"; | |
6885 if (-3L != jtt.bytecode.BC_lload_3.test(1, 1, 1, -3L)) { | |
6886 fail(runString); | |
6887 return; | |
6888 } | |
6889 // (1,1,1,10000) == 10000 | |
6890 runString = "(1,1,1,10000)"; | |
6891 if (10000L != jtt.bytecode.BC_lload_3.test(1, 1, 1, 10000L)) { | |
6892 fail(runString); | |
6893 return; | |
6894 } | |
6895 } catch (Throwable t) { | |
6896 fail(runString, t); | |
6897 return; | |
6898 } | |
6899 pass(); | |
6900 } | |
6901 | |
6902 static void jtt_bytecode_BC_lmul() { | |
6903 begin("jtt.bytecode.BC_lmul"); | |
6904 String runString = null; | |
6905 try { | |
6906 // (1,2) == 2 | |
6907 runString = "(1,2)"; | |
6908 if (2L != jtt.bytecode.BC_lmul.test(1L, 2L)) { | |
6909 fail(runString); | |
6910 return; | |
6911 } | |
6912 // (0,-1) == 0 | |
6913 runString = "(0,-1)"; | |
6914 if (0L != jtt.bytecode.BC_lmul.test(0L, -1L)) { | |
6915 fail(runString); | |
6916 return; | |
6917 } | |
6918 // (33,67) == 2211 | |
6919 runString = "(33,67)"; | |
6920 if (2211L != jtt.bytecode.BC_lmul.test(33L, 67L)) { | |
6921 fail(runString); | |
6922 return; | |
6923 } | |
6924 // (1,-1) == -1 | |
6925 runString = "(1,-1)"; | |
6926 if (-1L != jtt.bytecode.BC_lmul.test(1L, -1L)) { | |
6927 fail(runString); | |
6928 return; | |
6929 } | |
6930 // (-2147483648,1) == -2147483648 | |
6931 runString = "(-2147483648,1)"; | |
6932 if (-2147483648L != jtt.bytecode.BC_lmul.test(-2147483648L, 1L)) { | |
6933 fail(runString); | |
6934 return; | |
6935 } | |
6936 // (2147483647,-1) == -2147483647 | |
6937 runString = "(2147483647,-1)"; | |
6938 if (-2147483647L != jtt.bytecode.BC_lmul.test(2147483647L, -1L)) { | |
6939 fail(runString); | |
6940 return; | |
6941 } | |
6942 // (-2147483648,-1) == 2147483648 | |
6943 runString = "(-2147483648,-1)"; | |
6944 if (2147483648L != jtt.bytecode.BC_lmul.test(-2147483648L, -1L)) { | |
6945 fail(runString); | |
6946 return; | |
6947 } | |
6948 // (1000000,1000000) == 1000000000000 | |
6949 runString = "(1000000,1000000)"; | |
6950 if (1000000000000L != jtt.bytecode.BC_lmul.test(1000000L, 1000000L)) { | |
6951 fail(runString); | |
6952 return; | |
6953 } | |
6954 } catch (Throwable t) { | |
6955 fail(runString, t); | |
6956 return; | |
6957 } | |
6958 pass(); | |
6959 } | |
6960 | |
6961 static void jtt_bytecode_BC_lneg() { | |
6962 begin("jtt.bytecode.BC_lneg"); | |
6963 String runString = null; | |
6964 try { | |
6965 // (0) == 0 | |
6966 runString = "(0)"; | |
6967 if (0L != jtt.bytecode.BC_lneg.test(0L)) { | |
6968 fail(runString); | |
6969 return; | |
6970 } | |
6971 // (-1) == 1 | |
6972 runString = "(-1)"; | |
6973 if (1L != jtt.bytecode.BC_lneg.test(-1L)) { | |
6974 fail(runString); | |
6975 return; | |
6976 } | |
6977 // (7263) == -7263 | |
6978 runString = "(7263)"; | |
6979 if (-7263L != jtt.bytecode.BC_lneg.test(7263L)) { | |
6980 fail(runString); | |
6981 return; | |
6982 } | |
6983 // (-2147483648) == 2147483648 | |
6984 runString = "(-2147483648)"; | |
6985 if (2147483648L != jtt.bytecode.BC_lneg.test(-2147483648L)) { | |
6986 fail(runString); | |
6987 return; | |
6988 } | |
6989 } catch (Throwable t) { | |
6990 fail(runString, t); | |
6991 return; | |
6992 } | |
6993 pass(); | |
6994 } | |
6995 | |
6996 static void jtt_bytecode_BC_lookupswitch01() { | |
6997 begin("jtt.bytecode.BC_lookupswitch01"); | |
6998 String runString = null; | |
6999 try { | |
7000 // (0) == 42 | |
7001 runString = "(0)"; | |
7002 if (42 != jtt.bytecode.BC_lookupswitch01.test(0)) { | |
7003 fail(runString); | |
7004 return; | |
7005 } | |
7006 // (1) == 42 | |
7007 runString = "(1)"; | |
7008 if (42 != jtt.bytecode.BC_lookupswitch01.test(1)) { | |
7009 fail(runString); | |
7010 return; | |
7011 } | |
7012 // (66) == 42 | |
7013 runString = "(66)"; | |
7014 if (42 != jtt.bytecode.BC_lookupswitch01.test(66)) { | |
7015 fail(runString); | |
7016 return; | |
7017 } | |
7018 // (67) == 0 | |
7019 runString = "(67)"; | |
7020 if (0 != jtt.bytecode.BC_lookupswitch01.test(67)) { | |
7021 fail(runString); | |
7022 return; | |
7023 } | |
7024 // (68) == 42 | |
7025 runString = "(68)"; | |
7026 if (42 != jtt.bytecode.BC_lookupswitch01.test(68)) { | |
7027 fail(runString); | |
7028 return; | |
7029 } | |
7030 // (96) == 42 | |
7031 runString = "(96)"; | |
7032 if (42 != jtt.bytecode.BC_lookupswitch01.test(96)) { | |
7033 fail(runString); | |
7034 return; | |
7035 } | |
7036 // (97) == 1 | |
7037 runString = "(97)"; | |
7038 if (1 != jtt.bytecode.BC_lookupswitch01.test(97)) { | |
7039 fail(runString); | |
7040 return; | |
7041 } | |
7042 // (98) == 42 | |
7043 runString = "(98)"; | |
7044 if (42 != jtt.bytecode.BC_lookupswitch01.test(98)) { | |
7045 fail(runString); | |
7046 return; | |
7047 } | |
7048 // (106) == 42 | |
7049 runString = "(106)"; | |
7050 if (42 != jtt.bytecode.BC_lookupswitch01.test(106)) { | |
7051 fail(runString); | |
7052 return; | |
7053 } | |
7054 // (107) == 2 | |
7055 runString = "(107)"; | |
7056 if (2 != jtt.bytecode.BC_lookupswitch01.test(107)) { | |
7057 fail(runString); | |
7058 return; | |
7059 } | |
7060 // (108) == 42 | |
7061 runString = "(108)"; | |
7062 if (42 != jtt.bytecode.BC_lookupswitch01.test(108)) { | |
7063 fail(runString); | |
7064 return; | |
7065 } | |
7066 // (132) == 42 | |
7067 runString = "(132)"; | |
7068 if (42 != jtt.bytecode.BC_lookupswitch01.test(132)) { | |
7069 fail(runString); | |
7070 return; | |
7071 } | |
7072 // (133) == 3 | |
7073 runString = "(133)"; | |
7074 if (3 != jtt.bytecode.BC_lookupswitch01.test(133)) { | |
7075 fail(runString); | |
7076 return; | |
7077 } | |
7078 // (134) == 42 | |
7079 runString = "(134)"; | |
7080 if (42 != jtt.bytecode.BC_lookupswitch01.test(134)) { | |
7081 fail(runString); | |
7082 return; | |
7083 } | |
7084 // (211) == 42 | |
7085 runString = "(211)"; | |
7086 if (42 != jtt.bytecode.BC_lookupswitch01.test(211)) { | |
7087 fail(runString); | |
7088 return; | |
7089 } | |
7090 // (212) == 4 | |
7091 runString = "(212)"; | |
7092 if (4 != jtt.bytecode.BC_lookupswitch01.test(212)) { | |
7093 fail(runString); | |
7094 return; | |
7095 } | |
7096 // (213) == 42 | |
7097 runString = "(213)"; | |
7098 if (42 != jtt.bytecode.BC_lookupswitch01.test(213)) { | |
7099 fail(runString); | |
7100 return; | |
7101 } | |
7102 } catch (Throwable t) { | |
7103 fail(runString, t); | |
7104 return; | |
7105 } | |
7106 pass(); | |
7107 } | |
7108 | |
7109 static void jtt_bytecode_BC_lookupswitch02() { | |
7110 begin("jtt.bytecode.BC_lookupswitch02"); | |
7111 String runString = null; | |
7112 try { | |
7113 // (0) == 42 | |
7114 runString = "(0)"; | |
7115 if (42 != jtt.bytecode.BC_lookupswitch02.test(0)) { | |
7116 fail(runString); | |
7117 return; | |
7118 } | |
7119 // (1) == 42 | |
7120 runString = "(1)"; | |
7121 if (42 != jtt.bytecode.BC_lookupswitch02.test(1)) { | |
7122 fail(runString); | |
7123 return; | |
7124 } | |
7125 // (66) == 42 | |
7126 runString = "(66)"; | |
7127 if (42 != jtt.bytecode.BC_lookupswitch02.test(66)) { | |
7128 fail(runString); | |
7129 return; | |
7130 } | |
7131 // (67) == 0 | |
7132 runString = "(67)"; | |
7133 if (0 != jtt.bytecode.BC_lookupswitch02.test(67)) { | |
7134 fail(runString); | |
7135 return; | |
7136 } | |
7137 // (68) == 42 | |
7138 runString = "(68)"; | |
7139 if (42 != jtt.bytecode.BC_lookupswitch02.test(68)) { | |
7140 fail(runString); | |
7141 return; | |
7142 } | |
7143 // (96) == 42 | |
7144 runString = "(96)"; | |
7145 if (42 != jtt.bytecode.BC_lookupswitch02.test(96)) { | |
7146 fail(runString); | |
7147 return; | |
7148 } | |
7149 // (97) == 1 | |
7150 runString = "(97)"; | |
7151 if (1 != jtt.bytecode.BC_lookupswitch02.test(97)) { | |
7152 fail(runString); | |
7153 return; | |
7154 } | |
7155 // (98) == 42 | |
7156 runString = "(98)"; | |
7157 if (42 != jtt.bytecode.BC_lookupswitch02.test(98)) { | |
7158 fail(runString); | |
7159 return; | |
7160 } | |
7161 // (106) == 42 | |
7162 runString = "(106)"; | |
7163 if (42 != jtt.bytecode.BC_lookupswitch02.test(106)) { | |
7164 fail(runString); | |
7165 return; | |
7166 } | |
7167 // (107) == 2 | |
7168 runString = "(107)"; | |
7169 if (2 != jtt.bytecode.BC_lookupswitch02.test(107)) { | |
7170 fail(runString); | |
7171 return; | |
7172 } | |
7173 // (108) == 42 | |
7174 runString = "(108)"; | |
7175 if (42 != jtt.bytecode.BC_lookupswitch02.test(108)) { | |
7176 fail(runString); | |
7177 return; | |
7178 } | |
7179 // (132) == 42 | |
7180 runString = "(132)"; | |
7181 if (42 != jtt.bytecode.BC_lookupswitch02.test(132)) { | |
7182 fail(runString); | |
7183 return; | |
7184 } | |
7185 // (133) == 3 | |
7186 runString = "(133)"; | |
7187 if (3 != jtt.bytecode.BC_lookupswitch02.test(133)) { | |
7188 fail(runString); | |
7189 return; | |
7190 } | |
7191 // (134) == 42 | |
7192 runString = "(134)"; | |
7193 if (42 != jtt.bytecode.BC_lookupswitch02.test(134)) { | |
7194 fail(runString); | |
7195 return; | |
7196 } | |
7197 // (211) == 42 | |
7198 runString = "(211)"; | |
7199 if (42 != jtt.bytecode.BC_lookupswitch02.test(211)) { | |
7200 fail(runString); | |
7201 return; | |
7202 } | |
7203 // (212) == 4 | |
7204 runString = "(212)"; | |
7205 if (4 != jtt.bytecode.BC_lookupswitch02.test(212)) { | |
7206 fail(runString); | |
7207 return; | |
7208 } | |
7209 // (213) == 42 | |
7210 runString = "(213)"; | |
7211 if (42 != jtt.bytecode.BC_lookupswitch02.test(213)) { | |
7212 fail(runString); | |
7213 return; | |
7214 } | |
7215 // (-121) == 42 | |
7216 runString = "(-121)"; | |
7217 if (42 != jtt.bytecode.BC_lookupswitch02.test(-121)) { | |
7218 fail(runString); | |
7219 return; | |
7220 } | |
7221 // (-122) == 5 | |
7222 runString = "(-122)"; | |
7223 if (5 != jtt.bytecode.BC_lookupswitch02.test(-122)) { | |
7224 fail(runString); | |
7225 return; | |
7226 } | |
7227 // (-123) == 42 | |
7228 runString = "(-123)"; | |
7229 if (42 != jtt.bytecode.BC_lookupswitch02.test(-123)) { | |
7230 fail(runString); | |
7231 return; | |
7232 } | |
7233 } catch (Throwable t) { | |
7234 fail(runString, t); | |
7235 return; | |
7236 } | |
7237 pass(); | |
7238 } | |
7239 | |
7240 static void jtt_bytecode_BC_lookupswitch03() { | |
7241 begin("jtt.bytecode.BC_lookupswitch03"); | |
7242 String runString = null; | |
7243 try { | |
7244 // (0) == 42 | |
7245 runString = "(0)"; | |
7246 if (42 != jtt.bytecode.BC_lookupswitch03.test(0)) { | |
7247 fail(runString); | |
7248 return; | |
7249 } | |
7250 // (1) == 42 | |
7251 runString = "(1)"; | |
7252 if (42 != jtt.bytecode.BC_lookupswitch03.test(1)) { | |
7253 fail(runString); | |
7254 return; | |
7255 } | |
7256 // (66) == 42 | |
7257 runString = "(66)"; | |
7258 if (42 != jtt.bytecode.BC_lookupswitch03.test(66)) { | |
7259 fail(runString); | |
7260 return; | |
7261 } | |
7262 // (67) == 0 | |
7263 runString = "(67)"; | |
7264 if (0 != jtt.bytecode.BC_lookupswitch03.test(67)) { | |
7265 fail(runString); | |
7266 return; | |
7267 } | |
7268 // (68) == 42 | |
7269 runString = "(68)"; | |
7270 if (42 != jtt.bytecode.BC_lookupswitch03.test(68)) { | |
7271 fail(runString); | |
7272 return; | |
7273 } | |
7274 // (96) == 42 | |
7275 runString = "(96)"; | |
7276 if (42 != jtt.bytecode.BC_lookupswitch03.test(96)) { | |
7277 fail(runString); | |
7278 return; | |
7279 } | |
7280 // (97) == 1 | |
7281 runString = "(97)"; | |
7282 if (1 != jtt.bytecode.BC_lookupswitch03.test(97)) { | |
7283 fail(runString); | |
7284 return; | |
7285 } | |
7286 // (98) == 42 | |
7287 runString = "(98)"; | |
7288 if (42 != jtt.bytecode.BC_lookupswitch03.test(98)) { | |
7289 fail(runString); | |
7290 return; | |
7291 } | |
7292 // (106) == 42 | |
7293 runString = "(106)"; | |
7294 if (42 != jtt.bytecode.BC_lookupswitch03.test(106)) { | |
7295 fail(runString); | |
7296 return; | |
7297 } | |
7298 // (107) == 2 | |
7299 runString = "(107)"; | |
7300 if (2 != jtt.bytecode.BC_lookupswitch03.test(107)) { | |
7301 fail(runString); | |
7302 return; | |
7303 } | |
7304 // (108) == 42 | |
7305 runString = "(108)"; | |
7306 if (42 != jtt.bytecode.BC_lookupswitch03.test(108)) { | |
7307 fail(runString); | |
7308 return; | |
7309 } | |
7310 // (132) == 42 | |
7311 runString = "(132)"; | |
7312 if (42 != jtt.bytecode.BC_lookupswitch03.test(132)) { | |
7313 fail(runString); | |
7314 return; | |
7315 } | |
7316 // (133) == 3 | |
7317 runString = "(133)"; | |
7318 if (3 != jtt.bytecode.BC_lookupswitch03.test(133)) { | |
7319 fail(runString); | |
7320 return; | |
7321 } | |
7322 // (134) == 42 | |
7323 runString = "(134)"; | |
7324 if (42 != jtt.bytecode.BC_lookupswitch03.test(134)) { | |
7325 fail(runString); | |
7326 return; | |
7327 } | |
7328 // (211) == 42 | |
7329 runString = "(211)"; | |
7330 if (42 != jtt.bytecode.BC_lookupswitch03.test(211)) { | |
7331 fail(runString); | |
7332 return; | |
7333 } | |
7334 // (212) == 4 | |
7335 runString = "(212)"; | |
7336 if (4 != jtt.bytecode.BC_lookupswitch03.test(212)) { | |
7337 fail(runString); | |
7338 return; | |
7339 } | |
7340 // (213) == 42 | |
7341 runString = "(213)"; | |
7342 if (42 != jtt.bytecode.BC_lookupswitch03.test(213)) { | |
7343 fail(runString); | |
7344 return; | |
7345 } | |
7346 // (-121) == 42 | |
7347 runString = "(-121)"; | |
7348 if (42 != jtt.bytecode.BC_lookupswitch03.test(-121)) { | |
7349 fail(runString); | |
7350 return; | |
7351 } | |
7352 // (-122) == 5 | |
7353 runString = "(-122)"; | |
7354 if (5 != jtt.bytecode.BC_lookupswitch03.test(-122)) { | |
7355 fail(runString); | |
7356 return; | |
7357 } | |
7358 // (-123) == 42 | |
7359 runString = "(-123)"; | |
7360 if (42 != jtt.bytecode.BC_lookupswitch03.test(-123)) { | |
7361 fail(runString); | |
7362 return; | |
7363 } | |
7364 } catch (Throwable t) { | |
7365 fail(runString, t); | |
7366 return; | |
7367 } | |
7368 pass(); | |
7369 } | |
7370 | |
7371 static void jtt_bytecode_BC_lookupswitch04() { | |
7372 begin("jtt.bytecode.BC_lookupswitch04"); | |
7373 String runString = null; | |
7374 try { | |
7375 // (0) == 42 | |
7376 runString = "(0)"; | |
7377 if (42 != jtt.bytecode.BC_lookupswitch04.test(0)) { | |
7378 fail(runString); | |
7379 return; | |
7380 } | |
7381 // (1) == 42 | |
7382 runString = "(1)"; | |
7383 if (42 != jtt.bytecode.BC_lookupswitch04.test(1)) { | |
7384 fail(runString); | |
7385 return; | |
7386 } | |
7387 // (66) == 42 | |
7388 runString = "(66)"; | |
7389 if (42 != jtt.bytecode.BC_lookupswitch04.test(66)) { | |
7390 fail(runString); | |
7391 return; | |
7392 } | |
7393 // (67) == 0 | |
7394 runString = "(67)"; | |
7395 if (0 != jtt.bytecode.BC_lookupswitch04.test(67)) { | |
7396 fail(runString); | |
7397 return; | |
7398 } | |
7399 // (68) == 42 | |
7400 runString = "(68)"; | |
7401 if (42 != jtt.bytecode.BC_lookupswitch04.test(68)) { | |
7402 fail(runString); | |
7403 return; | |
7404 } | |
7405 // (96) == 42 | |
7406 runString = "(96)"; | |
7407 if (42 != jtt.bytecode.BC_lookupswitch04.test(96)) { | |
7408 fail(runString); | |
7409 return; | |
7410 } | |
7411 // (97) == 1 | |
7412 runString = "(97)"; | |
7413 if (1 != jtt.bytecode.BC_lookupswitch04.test(97)) { | |
7414 fail(runString); | |
7415 return; | |
7416 } | |
7417 // (98) == 42 | |
7418 runString = "(98)"; | |
7419 if (42 != jtt.bytecode.BC_lookupswitch04.test(98)) { | |
7420 fail(runString); | |
7421 return; | |
7422 } | |
7423 // (106) == 42 | |
7424 runString = "(106)"; | |
7425 if (42 != jtt.bytecode.BC_lookupswitch04.test(106)) { | |
7426 fail(runString); | |
7427 return; | |
7428 } | |
7429 // (107) == 2 | |
7430 runString = "(107)"; | |
7431 if (2 != jtt.bytecode.BC_lookupswitch04.test(107)) { | |
7432 fail(runString); | |
7433 return; | |
7434 } | |
7435 // (108) == 42 | |
7436 runString = "(108)"; | |
7437 if (42 != jtt.bytecode.BC_lookupswitch04.test(108)) { | |
7438 fail(runString); | |
7439 return; | |
7440 } | |
7441 // (132) == 42 | |
7442 runString = "(132)"; | |
7443 if (42 != jtt.bytecode.BC_lookupswitch04.test(132)) { | |
7444 fail(runString); | |
7445 return; | |
7446 } | |
7447 // (133) == 3 | |
7448 runString = "(133)"; | |
7449 if (3 != jtt.bytecode.BC_lookupswitch04.test(133)) { | |
7450 fail(runString); | |
7451 return; | |
7452 } | |
7453 // (134) == 42 | |
7454 runString = "(134)"; | |
7455 if (42 != jtt.bytecode.BC_lookupswitch04.test(134)) { | |
7456 fail(runString); | |
7457 return; | |
7458 } | |
7459 // (211) == 42 | |
7460 runString = "(211)"; | |
7461 if (42 != jtt.bytecode.BC_lookupswitch04.test(211)) { | |
7462 fail(runString); | |
7463 return; | |
7464 } | |
7465 // (212) == 4 | |
7466 runString = "(212)"; | |
7467 if (4 != jtt.bytecode.BC_lookupswitch04.test(212)) { | |
7468 fail(runString); | |
7469 return; | |
7470 } | |
7471 // (213) == 42 | |
7472 runString = "(213)"; | |
7473 if (42 != jtt.bytecode.BC_lookupswitch04.test(213)) { | |
7474 fail(runString); | |
7475 return; | |
7476 } | |
7477 // (-121) == 42 | |
7478 runString = "(-121)"; | |
7479 if (42 != jtt.bytecode.BC_lookupswitch04.test(-121)) { | |
7480 fail(runString); | |
7481 return; | |
7482 } | |
7483 // (-122) == 5 | |
7484 runString = "(-122)"; | |
7485 if (5 != jtt.bytecode.BC_lookupswitch04.test(-122)) { | |
7486 fail(runString); | |
7487 return; | |
7488 } | |
7489 // (-123) == 42 | |
7490 runString = "(-123)"; | |
7491 if (42 != jtt.bytecode.BC_lookupswitch04.test(-123)) { | |
7492 fail(runString); | |
7493 return; | |
7494 } | |
7495 } catch (Throwable t) { | |
7496 fail(runString, t); | |
7497 return; | |
7498 } | |
7499 pass(); | |
7500 } | |
7501 | |
7502 static void jtt_bytecode_BC_lor() { | |
7503 begin("jtt.bytecode.BC_lor"); | |
7504 String runString = null; | |
7505 try { | |
7506 // (1,2) == 3 | |
7507 runString = "(1,2)"; | |
7508 if (3L != jtt.bytecode.BC_lor.test(1L, 2L)) { | |
7509 fail(runString); | |
7510 return; | |
7511 } | |
7512 // (0,-1) == -1 | |
7513 runString = "(0,-1)"; | |
7514 if (-1L != jtt.bytecode.BC_lor.test(0L, -1L)) { | |
7515 fail(runString); | |
7516 return; | |
7517 } | |
7518 // (31,63) == 63 | |
7519 runString = "(31,63)"; | |
7520 if (63L != jtt.bytecode.BC_lor.test(31L, 63L)) { | |
7521 fail(runString); | |
7522 return; | |
7523 } | |
7524 // (6,4) == 6 | |
7525 runString = "(6,4)"; | |
7526 if (6L != jtt.bytecode.BC_lor.test(6L, 4L)) { | |
7527 fail(runString); | |
7528 return; | |
7529 } | |
7530 // (-2147483648,1) == -2147483647 | |
7531 runString = "(-2147483648,1)"; | |
7532 if (-2147483647L != jtt.bytecode.BC_lor.test(-2147483648L, 1L)) { | |
7533 fail(runString); | |
7534 return; | |
7535 } | |
7536 } catch (Throwable t) { | |
7537 fail(runString, t); | |
7538 return; | |
7539 } | |
7540 pass(); | |
7541 } | |
7542 | |
7543 static void jtt_bytecode_BC_lrem() { | |
7544 begin("jtt.bytecode.BC_lrem"); | |
7545 String runString = null; | |
7546 try { | |
7547 // (1,2) == 1 | |
7548 runString = "(1,2)"; | |
7549 if (1L != jtt.bytecode.BC_lrem.test(1L, 2L)) { | |
7550 fail(runString); | |
7551 return; | |
7552 } | |
7553 // (2,-1) == 0 | |
7554 runString = "(2,-1)"; | |
7555 if (0L != jtt.bytecode.BC_lrem.test(2L, -1L)) { | |
7556 fail(runString); | |
7557 return; | |
7558 } | |
7559 // (256,4) == 0 | |
7560 runString = "(256,4)"; | |
7561 if (0L != jtt.bytecode.BC_lrem.test(256L, 4L)) { | |
7562 fail(runString); | |
7563 return; | |
7564 } | |
7565 // (135,7) == 2 | |
7566 runString = "(135,7)"; | |
7567 if (2L != jtt.bytecode.BC_lrem.test(135L, 7L)) { | |
7568 fail(runString); | |
7569 return; | |
7570 } | |
7571 } catch (Throwable t) { | |
7572 fail(runString, t); | |
7573 return; | |
7574 } | |
7575 pass(); | |
7576 } | |
7577 | |
7578 static void jtt_bytecode_BC_lrem2() { | |
7579 begin("jtt.bytecode.BC_lrem2"); | |
7580 String runString = null; | |
7581 try { | |
7582 // (-9223372036854775808,-1) == 0 | |
7583 runString = "(-9223372036854775808,-1)"; | |
7584 if (0L != jtt.bytecode.BC_lrem2.test(-9223372036854775808L, -1)) { | |
7585 fail(runString); | |
7586 return; | |
7587 } | |
7588 // (-9223372036854775808,1) == 0 | |
7589 runString = "(-9223372036854775808,1)"; | |
7590 if (0L != jtt.bytecode.BC_lrem2.test(-9223372036854775808L, 1)) { | |
7591 fail(runString); | |
7592 return; | |
7593 } | |
7594 } catch (Throwable t) { | |
7595 fail(runString, t); | |
7596 return; | |
7597 } | |
7598 pass(); | |
7599 } | |
7600 | |
7601 static void jtt_bytecode_BC_lreturn() { | |
7602 begin("jtt.bytecode.BC_lreturn"); | |
7603 String runString = null; | |
7604 try { | |
7605 // (0) == 0 | |
7606 runString = "(0)"; | |
7607 if (0L != jtt.bytecode.BC_lreturn.test(0L)) { | |
7608 fail(runString); | |
7609 return; | |
7610 } | |
7611 // (1) == 1 | |
7612 runString = "(1)"; | |
7613 if (1L != jtt.bytecode.BC_lreturn.test(1L)) { | |
7614 fail(runString); | |
7615 return; | |
7616 } | |
7617 // (-1) == -1 | |
7618 runString = "(-1)"; | |
7619 if (-1L != jtt.bytecode.BC_lreturn.test(-1L)) { | |
7620 fail(runString); | |
7621 return; | |
7622 } | |
7623 // (256) == 256 | |
7624 runString = "(256)"; | |
7625 if (256L != jtt.bytecode.BC_lreturn.test(256L)) { | |
7626 fail(runString); | |
7627 return; | |
7628 } | |
7629 // (1000000000000) == 1000000000000 | |
7630 runString = "(1000000000000)"; | |
7631 if (1000000000000L != jtt.bytecode.BC_lreturn.test(1000000000000L)) { | |
7632 fail(runString); | |
7633 return; | |
7634 } | |
7635 } catch (Throwable t) { | |
7636 fail(runString, t); | |
7637 return; | |
7638 } | |
7639 pass(); | |
7640 } | |
7641 | |
7642 static void jtt_bytecode_BC_lshl() { | |
7643 begin("jtt.bytecode.BC_lshl"); | |
7644 String runString = null; | |
7645 try { | |
7646 // (1,2) == 4 | |
7647 runString = "(1,2)"; | |
7648 if (4L != jtt.bytecode.BC_lshl.test(1L, 2)) { | |
7649 fail(runString); | |
7650 return; | |
7651 } | |
7652 // (0,-1) == 0 | |
7653 runString = "(0,-1)"; | |
7654 if (0L != jtt.bytecode.BC_lshl.test(0L, -1)) { | |
7655 fail(runString); | |
7656 return; | |
7657 } | |
7658 // (31,1) == 62 | |
7659 runString = "(31,1)"; | |
7660 if (62L != jtt.bytecode.BC_lshl.test(31L, 1)) { | |
7661 fail(runString); | |
7662 return; | |
7663 } | |
7664 // (6,4) == 96 | |
7665 runString = "(6,4)"; | |
7666 if (96L != jtt.bytecode.BC_lshl.test(6L, 4)) { | |
7667 fail(runString); | |
7668 return; | |
7669 } | |
7670 // (-2147483648,1) == -4294967296 | |
7671 runString = "(-2147483648,1)"; | |
7672 if (-4294967296L != jtt.bytecode.BC_lshl.test(-2147483648L, 1)) { | |
7673 fail(runString); | |
7674 return; | |
7675 } | |
7676 } catch (Throwable t) { | |
7677 fail(runString, t); | |
7678 return; | |
7679 } | |
7680 pass(); | |
7681 } | |
7682 | |
7683 static void jtt_bytecode_BC_lshr() { | |
7684 begin("jtt.bytecode.BC_lshr"); | |
7685 String runString = null; | |
7686 try { | |
7687 // (1,2) == 0 | |
7688 runString = "(1,2)"; | |
7689 if (0L != jtt.bytecode.BC_lshr.test(1L, 2)) { | |
7690 fail(runString); | |
7691 return; | |
7692 } | |
7693 // (67,2) == 16 | |
7694 runString = "(67,2)"; | |
7695 if (16L != jtt.bytecode.BC_lshr.test(67L, 2)) { | |
7696 fail(runString); | |
7697 return; | |
7698 } | |
7699 // (31,1) == 15 | |
7700 runString = "(31,1)"; | |
7701 if (15L != jtt.bytecode.BC_lshr.test(31L, 1)) { | |
7702 fail(runString); | |
7703 return; | |
7704 } | |
7705 // (6,4) == 0 | |
7706 runString = "(6,4)"; | |
7707 if (0L != jtt.bytecode.BC_lshr.test(6L, 4)) { | |
7708 fail(runString); | |
7709 return; | |
7710 } | |
7711 // (-2147483648,16) == -32768 | |
7712 runString = "(-2147483648,16)"; | |
7713 if (-32768L != jtt.bytecode.BC_lshr.test(-2147483648L, 16)) { | |
7714 fail(runString); | |
7715 return; | |
7716 } | |
7717 } catch (Throwable t) { | |
7718 fail(runString, t); | |
7719 return; | |
7720 } | |
7721 pass(); | |
7722 } | |
7723 | |
7724 static void jtt_bytecode_BC_lsub() { | |
7725 begin("jtt.bytecode.BC_lsub"); | |
7726 String runString = null; | |
7727 try { | |
7728 // (1,-2) == 3 | |
7729 runString = "(1,-2)"; | |
7730 if (3L != jtt.bytecode.BC_lsub.test(1L, -2L)) { | |
7731 fail(runString); | |
7732 return; | |
7733 } | |
7734 // (0,1) == -1 | |
7735 runString = "(0,1)"; | |
7736 if (-1L != jtt.bytecode.BC_lsub.test(0L, 1L)) { | |
7737 fail(runString); | |
7738 return; | |
7739 } | |
7740 // (33,-67) == 100 | |
7741 runString = "(33,-67)"; | |
7742 if (100L != jtt.bytecode.BC_lsub.test(33L, -67L)) { | |
7743 fail(runString); | |
7744 return; | |
7745 } | |
7746 // (1,1) == 0 | |
7747 runString = "(1,1)"; | |
7748 if (0L != jtt.bytecode.BC_lsub.test(1L, 1L)) { | |
7749 fail(runString); | |
7750 return; | |
7751 } | |
7752 // (-2147483648,-1) == -2147483647 | |
7753 runString = "(-2147483648,-1)"; | |
7754 if (-2147483647L != jtt.bytecode.BC_lsub.test(-2147483648L, -1L)) { | |
7755 fail(runString); | |
7756 return; | |
7757 } | |
7758 // (2147483647,-1) == 2147483648 | |
7759 runString = "(2147483647,-1)"; | |
7760 if (2147483648L != jtt.bytecode.BC_lsub.test(2147483647L, -1L)) { | |
7761 fail(runString); | |
7762 return; | |
7763 } | |
7764 } catch (Throwable t) { | |
7765 fail(runString, t); | |
7766 return; | |
7767 } | |
7768 pass(); | |
7769 } | |
7770 | |
7771 static void jtt_bytecode_BC_lushr() { | |
7772 begin("jtt.bytecode.BC_lushr"); | |
7773 String runString = null; | |
7774 try { | |
7775 // (1,2) == 0 | |
7776 runString = "(1,2)"; | |
7777 if (0L != jtt.bytecode.BC_lushr.test(1L, 2)) { | |
7778 fail(runString); | |
7779 return; | |
7780 } | |
7781 // (67,2) == 16 | |
7782 runString = "(67,2)"; | |
7783 if (16L != jtt.bytecode.BC_lushr.test(67L, 2)) { | |
7784 fail(runString); | |
7785 return; | |
7786 } | |
7787 // (31,1) == 15 | |
7788 runString = "(31,1)"; | |
7789 if (15L != jtt.bytecode.BC_lushr.test(31L, 1)) { | |
7790 fail(runString); | |
7791 return; | |
7792 } | |
7793 // (6,4) == 0 | |
7794 runString = "(6,4)"; | |
7795 if (0L != jtt.bytecode.BC_lushr.test(6L, 4)) { | |
7796 fail(runString); | |
7797 return; | |
7798 } | |
7799 // (-2147483648,16) == 281474976677888 | |
7800 runString = "(-2147483648,16)"; | |
7801 if (281474976677888L != jtt.bytecode.BC_lushr | |
7802 .test(-2147483648L, 16)) { | |
7803 fail(runString); | |
7804 return; | |
7805 } | |
7806 } catch (Throwable t) { | |
7807 fail(runString, t); | |
7808 return; | |
7809 } | |
7810 pass(); | |
7811 } | |
7812 | |
7813 static void jtt_bytecode_BC_lxor() { | |
7814 begin("jtt.bytecode.BC_lxor"); | |
7815 String runString = null; | |
7816 try { | |
7817 // (1,2) == 3 | |
7818 runString = "(1,2)"; | |
7819 if (3L != jtt.bytecode.BC_lxor.test(1L, 2L)) { | |
7820 fail(runString); | |
7821 return; | |
7822 } | |
7823 // (0,-1) == -1 | |
7824 runString = "(0,-1)"; | |
7825 if (-1L != jtt.bytecode.BC_lxor.test(0L, -1L)) { | |
7826 fail(runString); | |
7827 return; | |
7828 } | |
7829 // (31,63) == 32 | |
7830 runString = "(31,63)"; | |
7831 if (32L != jtt.bytecode.BC_lxor.test(31L, 63L)) { | |
7832 fail(runString); | |
7833 return; | |
7834 } | |
7835 // (6,4) == 2 | |
7836 runString = "(6,4)"; | |
7837 if (2L != jtt.bytecode.BC_lxor.test(6L, 4L)) { | |
7838 fail(runString); | |
7839 return; | |
7840 } | |
7841 // (-2147483648,1) == -2147483647 | |
7842 runString = "(-2147483648,1)"; | |
7843 if (-2147483647L != jtt.bytecode.BC_lxor.test(-2147483648L, 1L)) { | |
7844 fail(runString); | |
7845 return; | |
7846 } | |
7847 } catch (Throwable t) { | |
7848 fail(runString, t); | |
7849 return; | |
7850 } | |
7851 pass(); | |
7852 } | |
7853 | |
7854 static void jtt_bytecode_BC_monitorenter() { | |
7855 begin("jtt.bytecode.BC_monitorenter"); | |
7856 String runString = null; | |
7857 try { | |
7858 // (0) == 0 | |
7859 runString = "(0)"; | |
7860 if (0 != jtt.bytecode.BC_monitorenter.test(0)) { | |
7861 fail(runString); | |
7862 return; | |
7863 } | |
7864 // (1) == 1 | |
7865 runString = "(1)"; | |
7866 if (1 != jtt.bytecode.BC_monitorenter.test(1)) { | |
7867 fail(runString); | |
7868 return; | |
7869 } | |
7870 // (-2) == -2 | |
7871 runString = "(-2)"; | |
7872 if (-2 != jtt.bytecode.BC_monitorenter.test(-2)) { | |
7873 fail(runString); | |
7874 return; | |
7875 } | |
7876 } catch (Throwable t) { | |
7877 fail(runString, t); | |
7878 return; | |
7879 } | |
7880 pass(); | |
7881 } | |
7882 | |
7883 static void jtt_bytecode_BC_monitorenter02() { | |
7884 begin("jtt.bytecode.BC_monitorenter02"); | |
7885 String runString = null; | |
7886 try { | |
7887 // (0,1) == 0 | |
7888 runString = "(0,1)"; | |
7889 if (0 != jtt.bytecode.BC_monitorenter02.test(0, 1)) { | |
7890 fail(runString); | |
7891 return; | |
7892 } | |
7893 // (1,1) == 1 | |
7894 runString = "(1,1)"; | |
7895 if (1 != jtt.bytecode.BC_monitorenter02.test(1, 1)) { | |
7896 fail(runString); | |
7897 return; | |
7898 } | |
7899 // (-2,1) == -2 | |
7900 runString = "(-2,1)"; | |
7901 if (-2 != jtt.bytecode.BC_monitorenter02.test(-2, 1)) { | |
7902 fail(runString); | |
7903 return; | |
7904 } | |
7905 } catch (Throwable t) { | |
7906 fail(runString, t); | |
7907 return; | |
7908 } | |
7909 pass(); | |
7910 } | |
7911 | |
7912 static void jtt_bytecode_BC_multianewarray01() { | |
7913 begin("jtt.bytecode.BC_multianewarray01"); | |
7914 String runString = null; | |
7915 try { | |
7916 // (0) == 0 | |
7917 runString = "(0)"; | |
7918 if (0 != jtt.bytecode.BC_multianewarray01.test(0)) { | |
7919 fail(runString); | |
7920 return; | |
7921 } | |
7922 // (1) == 1 | |
7923 runString = "(1)"; | |
7924 if (1 != jtt.bytecode.BC_multianewarray01.test(1)) { | |
7925 fail(runString); | |
7926 return; | |
7927 } | |
7928 } catch (Throwable t) { | |
7929 fail(runString, t); | |
7930 return; | |
7931 } | |
7932 pass(); | |
7933 } | |
7934 | |
7935 static void jtt_bytecode_BC_multianewarray02() { | |
7936 begin("jtt.bytecode.BC_multianewarray02"); | |
7937 String runString = null; | |
7938 try { | |
7939 // (0) == 0 | |
7940 runString = "(0)"; | |
7941 if (0 != jtt.bytecode.BC_multianewarray02.test(0)) { | |
7942 fail(runString); | |
7943 return; | |
7944 } | |
7945 // (1) == 1 | |
7946 runString = "(1)"; | |
7947 if (1 != jtt.bytecode.BC_multianewarray02.test(1)) { | |
7948 fail(runString); | |
7949 return; | |
7950 } | |
7951 } catch (Throwable t) { | |
7952 fail(runString, t); | |
7953 return; | |
7954 } | |
7955 pass(); | |
7956 } | |
7957 | |
7958 static void jtt_bytecode_BC_multianewarray03() { | |
7959 begin("jtt.bytecode.BC_multianewarray03"); | |
7960 String runString = null; | |
7961 try { | |
7962 // (1) == 4 | |
7963 runString = "(1)"; | |
7964 if (4 != jtt.bytecode.BC_multianewarray03.test(1)) { | |
7965 fail(runString); | |
7966 return; | |
7967 } | |
7968 // (2) == 8 | |
7969 runString = "(2)"; | |
7970 if (8 != jtt.bytecode.BC_multianewarray03.test(2)) { | |
7971 fail(runString); | |
7972 return; | |
7973 } | |
7974 // (3) == 12 | |
7975 runString = "(3)"; | |
7976 if (12 != jtt.bytecode.BC_multianewarray03.test(3)) { | |
7977 fail(runString); | |
7978 return; | |
7979 } | |
7980 } catch (Throwable t) { | |
7981 fail(runString, t); | |
7982 return; | |
7983 } | |
7984 pass(); | |
7985 } | |
7986 | |
7987 static void jtt_bytecode_BC_multianewarray04() { | |
7988 begin("jtt.bytecode.BC_multianewarray04"); | |
7989 String runString = null; | |
7990 try { | |
7991 // (1) == 41 | |
7992 runString = "(1)"; | |
7993 if (41 != jtt.bytecode.BC_multianewarray04.test(1)) { | |
7994 fail(runString); | |
7995 return; | |
7996 } | |
7997 // (2) == 81 | |
7998 runString = "(2)"; | |
7999 if (81 != jtt.bytecode.BC_multianewarray04.test(2)) { | |
8000 fail(runString); | |
8001 return; | |
8002 } | |
8003 } catch (Throwable t) { | |
8004 fail(runString, t); | |
8005 return; | |
8006 } | |
8007 pass(); | |
8008 } | |
8009 | |
8010 static void jtt_bytecode_BC_new() { | |
8011 begin("jtt.bytecode.BC_new"); | |
8012 String runString = null; | |
8013 try { | |
8014 // (0) == 0 | |
8015 runString = "(0)"; | |
8016 if (0 != jtt.bytecode.BC_new.test(0)) { | |
8017 fail(runString); | |
8018 return; | |
8019 } | |
8020 } catch (Throwable t) { | |
8021 fail(runString, t); | |
8022 return; | |
8023 } | |
8024 pass(); | |
8025 } | |
8026 | |
8027 static void jtt_bytecode_BC_newarray() { | |
8028 begin("jtt.bytecode.BC_newarray"); | |
8029 String runString = null; | |
8030 try { | |
8031 // (0) == 0 | |
8032 runString = "(0)"; | |
8033 if (0 != jtt.bytecode.BC_newarray.test(0)) { | |
8034 fail(runString); | |
8035 return; | |
8036 } | |
8037 // (1) == 1 | |
8038 runString = "(1)"; | |
8039 if (1 != jtt.bytecode.BC_newarray.test(1)) { | |
8040 fail(runString); | |
8041 return; | |
8042 } | |
8043 } catch (Throwable t) { | |
8044 fail(runString, t); | |
8045 return; | |
8046 } | |
8047 pass(); | |
8048 } | |
8049 | |
8050 static void jtt_bytecode_BC_putfield() { | |
8051 begin("jtt.bytecode.BC_putfield"); | |
8052 String runString = null; | |
8053 try { | |
8054 // (0) == 0 | |
8055 runString = "(0)"; | |
8056 if (0 != jtt.bytecode.BC_putfield.test(0)) { | |
8057 fail(runString); | |
8058 return; | |
8059 } | |
8060 // (1) == 1 | |
8061 runString = "(1)"; | |
8062 if (1 != jtt.bytecode.BC_putfield.test(1)) { | |
8063 fail(runString); | |
8064 return; | |
8065 } | |
8066 // (2) == 2 | |
8067 runString = "(2)"; | |
8068 if (2 != jtt.bytecode.BC_putfield.test(2)) { | |
8069 fail(runString); | |
8070 return; | |
8071 } | |
8072 // (-4) == -4 | |
8073 runString = "(-4)"; | |
8074 if (-4 != jtt.bytecode.BC_putfield.test(-4)) { | |
8075 fail(runString); | |
8076 return; | |
8077 } | |
8078 } catch (Throwable t) { | |
8079 fail(runString, t); | |
8080 return; | |
8081 } | |
8082 pass(); | |
8083 } | |
8084 | |
8085 static void jtt_bytecode_BC_putstatic() { | |
8086 begin("jtt.bytecode.BC_putstatic"); | |
8087 String runString = null; | |
8088 try { | |
8089 // (0) == 0 | |
8090 runString = "(0)"; | |
8091 if (0 != jtt.bytecode.BC_putstatic.test(0)) { | |
8092 fail(runString); | |
8093 return; | |
8094 } | |
8095 // (1) == 1 | |
8096 runString = "(1)"; | |
8097 if (1 != jtt.bytecode.BC_putstatic.test(1)) { | |
8098 fail(runString); | |
8099 return; | |
8100 } | |
8101 // (2) == 2 | |
8102 runString = "(2)"; | |
8103 if (2 != jtt.bytecode.BC_putstatic.test(2)) { | |
8104 fail(runString); | |
8105 return; | |
8106 } | |
8107 // (3) == 3 | |
8108 runString = "(3)"; | |
8109 if (3 != jtt.bytecode.BC_putstatic.test(3)) { | |
8110 fail(runString); | |
8111 return; | |
8112 } | |
8113 // (-4) == -4 | |
8114 runString = "(-4)"; | |
8115 if (-4 != jtt.bytecode.BC_putstatic.test(-4)) { | |
8116 fail(runString); | |
8117 return; | |
8118 } | |
8119 } catch (Throwable t) { | |
8120 fail(runString, t); | |
8121 return; | |
8122 } | |
8123 pass(); | |
8124 } | |
8125 | |
8126 static void jtt_bytecode_BC_saload() { | |
8127 begin("jtt.bytecode.BC_saload"); | |
8128 String runString = null; | |
8129 try { | |
8130 // (0) == 0 | |
8131 runString = "(0)"; | |
8132 if ((short) 0 != jtt.bytecode.BC_saload.test(0)) { | |
8133 fail(runString); | |
8134 return; | |
8135 } | |
8136 // (1) == -1 | |
8137 runString = "(1)"; | |
8138 if ((short) -1 != jtt.bytecode.BC_saload.test(1)) { | |
8139 fail(runString); | |
8140 return; | |
8141 } | |
8142 // (2) == 4 | |
8143 runString = "(2)"; | |
8144 if ((short) 4 != jtt.bytecode.BC_saload.test(2)) { | |
8145 fail(runString); | |
8146 return; | |
8147 } | |
8148 // (3) == 10000 | |
8149 runString = "(3)"; | |
8150 if ((short) 10000 != jtt.bytecode.BC_saload.test(3)) { | |
8151 fail(runString); | |
8152 return; | |
8153 } | |
8154 } catch (Throwable t) { | |
8155 fail(runString, t); | |
8156 return; | |
8157 } | |
8158 pass(); | |
8159 } | |
8160 | |
8161 static void jtt_bytecode_BC_sastore() { | |
8162 begin("jtt.bytecode.BC_sastore"); | |
8163 String runString = null; | |
8164 try { | |
8165 // (0,0) == 0 | |
8166 runString = "(0,0)"; | |
8167 if ((short) 0 != jtt.bytecode.BC_sastore.test(0, (short) 0)) { | |
8168 fail(runString); | |
8169 return; | |
8170 } | |
8171 // (1,-1) == -1 | |
8172 runString = "(1,-1)"; | |
8173 if ((short) -1 != jtt.bytecode.BC_sastore.test(1, (short) -1)) { | |
8174 fail(runString); | |
8175 return; | |
8176 } | |
8177 // (2,11) == 11 | |
8178 runString = "(2,11)"; | |
8179 if ((short) 11 != jtt.bytecode.BC_sastore.test(2, (short) 11)) { | |
8180 fail(runString); | |
8181 return; | |
8182 } | |
8183 // (3,-14) == -14 | |
8184 runString = "(3,-14)"; | |
8185 if ((short) -14 != jtt.bytecode.BC_sastore.test(3, (short) -14)) { | |
8186 fail(runString); | |
8187 return; | |
8188 } | |
8189 } catch (Throwable t) { | |
8190 fail(runString, t); | |
8191 return; | |
8192 } | |
8193 pass(); | |
8194 } | |
8195 | |
8196 static void jtt_bytecode_BC_tableswitch() { | |
8197 begin("jtt.bytecode.BC_tableswitch"); | |
8198 String runString = null; | |
8199 try { | |
8200 // (-1) == 42 | |
8201 runString = "(-1)"; | |
8202 if (42 != jtt.bytecode.BC_tableswitch.test(-1)) { | |
8203 fail(runString); | |
8204 return; | |
8205 } | |
8206 // (0) == 10 | |
8207 runString = "(0)"; | |
8208 if (10 != jtt.bytecode.BC_tableswitch.test(0)) { | |
8209 fail(runString); | |
8210 return; | |
8211 } | |
8212 // (1) == 20 | |
8213 runString = "(1)"; | |
8214 if (20 != jtt.bytecode.BC_tableswitch.test(1)) { | |
8215 fail(runString); | |
8216 return; | |
8217 } | |
8218 // (2) == 30 | |
8219 runString = "(2)"; | |
8220 if (30 != jtt.bytecode.BC_tableswitch.test(2)) { | |
8221 fail(runString); | |
8222 return; | |
8223 } | |
8224 // (3) == 42 | |
8225 runString = "(3)"; | |
8226 if (42 != jtt.bytecode.BC_tableswitch.test(3)) { | |
8227 fail(runString); | |
8228 return; | |
8229 } | |
8230 // (4) == 40 | |
8231 runString = "(4)"; | |
8232 if (40 != jtt.bytecode.BC_tableswitch.test(4)) { | |
8233 fail(runString); | |
8234 return; | |
8235 } | |
8236 // (5) == 50 | |
8237 runString = "(5)"; | |
8238 if (50 != jtt.bytecode.BC_tableswitch.test(5)) { | |
8239 fail(runString); | |
8240 return; | |
8241 } | |
8242 // (6) == 42 | |
8243 runString = "(6)"; | |
8244 if (42 != jtt.bytecode.BC_tableswitch.test(6)) { | |
8245 fail(runString); | |
8246 return; | |
8247 } | |
8248 } catch (Throwable t) { | |
8249 fail(runString, t); | |
8250 return; | |
8251 } | |
8252 pass(); | |
8253 } | |
8254 | |
8255 static void jtt_bytecode_BC_tableswitch2() { | |
8256 begin("jtt.bytecode.BC_tableswitch2"); | |
8257 String runString = null; | |
8258 try { | |
8259 // (-1) == 11 | |
8260 runString = "(-1)"; | |
8261 if (11 != jtt.bytecode.BC_tableswitch2.test(-1)) { | |
8262 fail(runString); | |
8263 return; | |
8264 } | |
8265 // (0) == 11 | |
8266 runString = "(0)"; | |
8267 if (11 != jtt.bytecode.BC_tableswitch2.test(0)) { | |
8268 fail(runString); | |
8269 return; | |
8270 } | |
8271 // (1) == 11 | |
8272 runString = "(1)"; | |
8273 if (11 != jtt.bytecode.BC_tableswitch2.test(1)) { | |
8274 fail(runString); | |
8275 return; | |
8276 } | |
8277 // (5) == 55 | |
8278 runString = "(5)"; | |
8279 if (55 != jtt.bytecode.BC_tableswitch2.test(5)) { | |
8280 fail(runString); | |
8281 return; | |
8282 } | |
8283 // (6) == 66 | |
8284 runString = "(6)"; | |
8285 if (66 != jtt.bytecode.BC_tableswitch2.test(6)) { | |
8286 fail(runString); | |
8287 return; | |
8288 } | |
8289 // (7) == 77 | |
8290 runString = "(7)"; | |
8291 if (77 != jtt.bytecode.BC_tableswitch2.test(7)) { | |
8292 fail(runString); | |
8293 return; | |
8294 } | |
8295 // (8) == 11 | |
8296 runString = "(8)"; | |
8297 if (11 != jtt.bytecode.BC_tableswitch2.test(8)) { | |
8298 fail(runString); | |
8299 return; | |
8300 } | |
8301 } catch (Throwable t) { | |
8302 fail(runString, t); | |
8303 return; | |
8304 } | |
8305 pass(); | |
8306 } | |
8307 | |
8308 static void jtt_bytecode_BC_tableswitch3() { | |
8309 begin("jtt.bytecode.BC_tableswitch3"); | |
8310 String runString = null; | |
8311 try { | |
8312 // (-1) == 11 | |
8313 runString = "(-1)"; | |
8314 if (11 != jtt.bytecode.BC_tableswitch3.test(-1)) { | |
8315 fail(runString); | |
8316 return; | |
8317 } | |
8318 // (-2) == 22 | |
8319 runString = "(-2)"; | |
8320 if (22 != jtt.bytecode.BC_tableswitch3.test(-2)) { | |
8321 fail(runString); | |
8322 return; | |
8323 } | |
8324 // (-3) == 99 | |
8325 runString = "(-3)"; | |
8326 if (99 != jtt.bytecode.BC_tableswitch3.test(-3)) { | |
8327 fail(runString); | |
8328 return; | |
8329 } | |
8330 // (-4) == 99 | |
8331 runString = "(-4)"; | |
8332 if (99 != jtt.bytecode.BC_tableswitch3.test(-4)) { | |
8333 fail(runString); | |
8334 return; | |
8335 } | |
8336 // (1) == 77 | |
8337 runString = "(1)"; | |
8338 if (77 != jtt.bytecode.BC_tableswitch3.test(1)) { | |
8339 fail(runString); | |
8340 return; | |
8341 } | |
8342 // (2) == 99 | |
8343 runString = "(2)"; | |
8344 if (99 != jtt.bytecode.BC_tableswitch3.test(2)) { | |
8345 fail(runString); | |
8346 return; | |
8347 } | |
8348 // (10) == 99 | |
8349 runString = "(10)"; | |
8350 if (99 != jtt.bytecode.BC_tableswitch3.test(10)) { | |
8351 fail(runString); | |
8352 return; | |
8353 } | |
8354 } catch (Throwable t) { | |
8355 fail(runString, t); | |
8356 return; | |
8357 } | |
8358 pass(); | |
8359 } | |
8360 | |
8361 static void jtt_bytecode_BC_tableswitch4() { | |
8362 begin("jtt.bytecode.BC_tableswitch4"); | |
8363 String runString = null; | |
8364 try { | |
8365 // (-1) == 11 | |
8366 runString = "(-1)"; | |
8367 if (11 != jtt.bytecode.BC_tableswitch4.test(-1)) { | |
8368 fail(runString); | |
8369 return; | |
8370 } | |
8371 // (0) == 11 | |
8372 runString = "(0)"; | |
8373 if (11 != jtt.bytecode.BC_tableswitch4.test(0)) { | |
8374 fail(runString); | |
8375 return; | |
8376 } | |
8377 // (1) == 11 | |
8378 runString = "(1)"; | |
8379 if (11 != jtt.bytecode.BC_tableswitch4.test(1)) { | |
8380 fail(runString); | |
8381 return; | |
8382 } | |
8383 // (-5) == 55 | |
8384 runString = "(-5)"; | |
8385 if (55 != jtt.bytecode.BC_tableswitch4.test(-5)) { | |
8386 fail(runString); | |
8387 return; | |
8388 } | |
8389 // (-4) == 44 | |
8390 runString = "(-4)"; | |
8391 if (44 != jtt.bytecode.BC_tableswitch4.test(-4)) { | |
8392 fail(runString); | |
8393 return; | |
8394 } | |
8395 // (-3) == 33 | |
8396 runString = "(-3)"; | |
8397 if (33 != jtt.bytecode.BC_tableswitch4.test(-3)) { | |
8398 fail(runString); | |
8399 return; | |
8400 } | |
8401 // (-8) == 11 | |
8402 runString = "(-8)"; | |
8403 if (11 != jtt.bytecode.BC_tableswitch4.test(-8)) { | |
8404 fail(runString); | |
8405 return; | |
8406 } | |
8407 } catch (Throwable t) { | |
8408 fail(runString, t); | |
8409 return; | |
8410 } | |
8411 pass(); | |
8412 } | |
8413 | |
8414 static void jtt_bytecode_BC_wide01() { | |
8415 begin("jtt.bytecode.BC_wide01"); | |
8416 String runString = null; | |
8417 try { | |
8418 // (0) == 11 | |
8419 runString = "(0)"; | |
8420 if (11 != jtt.bytecode.BC_wide01.test(0)) { | |
8421 fail(runString); | |
8422 return; | |
8423 } | |
8424 // (1) == 12 | |
8425 runString = "(1)"; | |
8426 if (12 != jtt.bytecode.BC_wide01.test(1)) { | |
8427 fail(runString); | |
8428 return; | |
8429 } | |
8430 } catch (Throwable t) { | |
8431 fail(runString, t); | |
8432 return; | |
8433 } | |
8434 pass(); | |
8435 } | |
8436 | |
8437 static void jtt_bytecode_BC_wide02() { | |
8438 begin("jtt.bytecode.BC_wide02"); | |
8439 String runString = null; | |
8440 try { | |
8441 // (0) == 11 | |
8442 runString = "(0)"; | |
8443 if (11 != jtt.bytecode.BC_wide02.test(0)) { | |
8444 fail(runString); | |
8445 return; | |
8446 } | |
8447 // (1) == 12 | |
8448 runString = "(1)"; | |
8449 if (12 != jtt.bytecode.BC_wide02.test(1)) { | |
8450 fail(runString); | |
8451 return; | |
8452 } | |
8453 } catch (Throwable t) { | |
8454 fail(runString, t); | |
8455 return; | |
8456 } | |
8457 pass(); | |
8458 } | |
8459 | |
8460 static void jtt_optimize_ArrayLength01() { | |
8461 begin("jtt.optimize.ArrayLength01"); | |
8462 String runString = null; | |
8463 try { | |
8464 // (0) == 5 | |
8465 runString = "(0)"; | |
8466 if (5 != jtt.optimize.ArrayLength01.test(0)) { | |
8467 fail(runString); | |
8468 return; | |
8469 } | |
8470 // (1) == 6 | |
8471 runString = "(1)"; | |
8472 if (6 != jtt.optimize.ArrayLength01.test(1)) { | |
8473 fail(runString); | |
8474 return; | |
8475 } | |
8476 // (2) == 7 | |
8477 runString = "(2)"; | |
8478 if (7 != jtt.optimize.ArrayLength01.test(2)) { | |
8479 fail(runString); | |
8480 return; | |
8481 } | |
8482 // (3) == 8 | |
8483 runString = "(3)"; | |
8484 if (8 != jtt.optimize.ArrayLength01.test(3)) { | |
8485 fail(runString); | |
8486 return; | |
8487 } | |
8488 // (4) == 4 | |
8489 runString = "(4)"; | |
8490 if (4 != jtt.optimize.ArrayLength01.test(4)) { | |
8491 fail(runString); | |
8492 return; | |
8493 } | |
8494 } catch (Throwable t) { | |
8495 fail(runString, t); | |
8496 return; | |
8497 } | |
8498 pass(); | |
8499 } | |
8500 | |
8501 static void jtt_optimize_BC_idiv_16() { | |
8502 begin("jtt.optimize.BC_idiv_16"); | |
8503 String runString = null; | |
8504 try { | |
8505 // (0,0) == 0 | |
8506 runString = "(0,0)"; | |
8507 if (0 != jtt.optimize.BC_idiv_16.test(0, 0)) { | |
8508 fail(runString); | |
8509 return; | |
8510 } | |
8511 // (0,16) == 1 | |
8512 runString = "(0,16)"; | |
8513 if (1 != jtt.optimize.BC_idiv_16.test(0, 16)) { | |
8514 fail(runString); | |
8515 return; | |
8516 } | |
8517 // (0,17) == 1 | |
8518 runString = "(0,17)"; | |
8519 if (1 != jtt.optimize.BC_idiv_16.test(0, 17)) { | |
8520 fail(runString); | |
8521 return; | |
8522 } | |
8523 // (0,-1) == 0 | |
8524 runString = "(0,-1)"; | |
8525 if (0 != jtt.optimize.BC_idiv_16.test(0, -1)) { | |
8526 fail(runString); | |
8527 return; | |
8528 } | |
8529 // (0,-16) == -1 | |
8530 runString = "(0,-16)"; | |
8531 if (-1 != jtt.optimize.BC_idiv_16.test(0, -16)) { | |
8532 fail(runString); | |
8533 return; | |
8534 } | |
8535 // (0,-17) == -1 | |
8536 runString = "(0,-17)"; | |
8537 if (-1 != jtt.optimize.BC_idiv_16.test(0, -17)) { | |
8538 fail(runString); | |
8539 return; | |
8540 } | |
8541 // (0,-1024) == -64 | |
8542 runString = "(0,-1024)"; | |
8543 if (-64 != jtt.optimize.BC_idiv_16.test(0, -1024)) { | |
8544 fail(runString); | |
8545 return; | |
8546 } | |
8547 // (1,0) == 0 | |
8548 runString = "(1,0)"; | |
8549 if (0 != jtt.optimize.BC_idiv_16.test(1, 0)) { | |
8550 fail(runString); | |
8551 return; | |
8552 } | |
8553 // (1,16) == 1 | |
8554 runString = "(1,16)"; | |
8555 if (1 != jtt.optimize.BC_idiv_16.test(1, 16)) { | |
8556 fail(runString); | |
8557 return; | |
8558 } | |
8559 // (1,17) == 1 | |
8560 runString = "(1,17)"; | |
8561 if (1 != jtt.optimize.BC_idiv_16.test(1, 17)) { | |
8562 fail(runString); | |
8563 return; | |
8564 } | |
8565 // (1,-1) == 0 | |
8566 runString = "(1,-1)"; | |
8567 if (0 != jtt.optimize.BC_idiv_16.test(1, -1)) { | |
8568 fail(runString); | |
8569 return; | |
8570 } | |
8571 // (1,-16) == -1 | |
8572 runString = "(1,-16)"; | |
8573 if (-1 != jtt.optimize.BC_idiv_16.test(1, -16)) { | |
8574 fail(runString); | |
8575 return; | |
8576 } | |
8577 // (1,-17) == -1 | |
8578 runString = "(1,-17)"; | |
8579 if (-1 != jtt.optimize.BC_idiv_16.test(1, -17)) { | |
8580 fail(runString); | |
8581 return; | |
8582 } | |
8583 // (1,-1024) == -64 | |
8584 runString = "(1,-1024)"; | |
8585 if (-64 != jtt.optimize.BC_idiv_16.test(1, -1024)) { | |
8586 fail(runString); | |
8587 return; | |
8588 } | |
8589 } catch (Throwable t) { | |
8590 fail(runString, t); | |
8591 return; | |
8592 } | |
8593 pass(); | |
8594 } | |
8595 | |
8596 static void jtt_optimize_BC_idiv_4() { | |
8597 begin("jtt.optimize.BC_idiv_4"); | |
8598 String runString = null; | |
8599 try { | |
8600 // (0) == 0 | |
8601 runString = "(0)"; | |
8602 if (0 != jtt.optimize.BC_idiv_4.test(0)) { | |
8603 fail(runString); | |
8604 return; | |
8605 } | |
8606 // (4) == 1 | |
8607 runString = "(4)"; | |
8608 if (1 != jtt.optimize.BC_idiv_4.test(4)) { | |
8609 fail(runString); | |
8610 return; | |
8611 } | |
8612 // (5) == 1 | |
8613 runString = "(5)"; | |
8614 if (1 != jtt.optimize.BC_idiv_4.test(5)) { | |
8615 fail(runString); | |
8616 return; | |
8617 } | |
8618 // (-1) == 0 | |
8619 runString = "(-1)"; | |
8620 if (0 != jtt.optimize.BC_idiv_4.test(-1)) { | |
8621 fail(runString); | |
8622 return; | |
8623 } | |
8624 // (-4) == -1 | |
8625 runString = "(-4)"; | |
8626 if (-1 != jtt.optimize.BC_idiv_4.test(-4)) { | |
8627 fail(runString); | |
8628 return; | |
8629 } | |
8630 // (-5) == -1 | |
8631 runString = "(-5)"; | |
8632 if (-1 != jtt.optimize.BC_idiv_4.test(-5)) { | |
8633 fail(runString); | |
8634 return; | |
8635 } | |
8636 // (-256) == -64 | |
8637 runString = "(-256)"; | |
8638 if (-64 != jtt.optimize.BC_idiv_4.test(-256)) { | |
8639 fail(runString); | |
8640 return; | |
8641 } | |
8642 } catch (Throwable t) { | |
8643 fail(runString, t); | |
8644 return; | |
8645 } | |
8646 pass(); | |
8647 } | |
8648 | |
8649 static void jtt_optimize_BC_imul_16() { | |
8650 begin("jtt.optimize.BC_imul_16"); | |
8651 String runString = null; | |
8652 try { | |
8653 // (0,0) == 0 | |
8654 runString = "(0,0)"; | |
8655 if (0 != jtt.optimize.BC_imul_16.test(0, 0)) { | |
8656 fail(runString); | |
8657 return; | |
8658 } | |
8659 // (0,16) == 256 | |
8660 runString = "(0,16)"; | |
8661 if (256 != jtt.optimize.BC_imul_16.test(0, 16)) { | |
8662 fail(runString); | |
8663 return; | |
8664 } | |
8665 // (0,17) == 272 | |
8666 runString = "(0,17)"; | |
8667 if (272 != jtt.optimize.BC_imul_16.test(0, 17)) { | |
8668 fail(runString); | |
8669 return; | |
8670 } | |
8671 // (0,-1) == -16 | |
8672 runString = "(0,-1)"; | |
8673 if (-16 != jtt.optimize.BC_imul_16.test(0, -1)) { | |
8674 fail(runString); | |
8675 return; | |
8676 } | |
8677 // (0,-16) == -256 | |
8678 runString = "(0,-16)"; | |
8679 if (-256 != jtt.optimize.BC_imul_16.test(0, -16)) { | |
8680 fail(runString); | |
8681 return; | |
8682 } | |
8683 // (0,-17) == -272 | |
8684 runString = "(0,-17)"; | |
8685 if (-272 != jtt.optimize.BC_imul_16.test(0, -17)) { | |
8686 fail(runString); | |
8687 return; | |
8688 } | |
8689 // (0,2147483647) == -16 | |
8690 runString = "(0,2147483647)"; | |
8691 if (-16 != jtt.optimize.BC_imul_16.test(0, 2147483647)) { | |
8692 fail(runString); | |
8693 return; | |
8694 } | |
8695 // (0,-2147483648) == 0 | |
8696 runString = "(0,-2147483648)"; | |
8697 if (0 != jtt.optimize.BC_imul_16.test(0, -2147483648)) { | |
8698 fail(runString); | |
8699 return; | |
8700 } | |
8701 // (1,0) == 0 | |
8702 runString = "(1,0)"; | |
8703 if (0 != jtt.optimize.BC_imul_16.test(1, 0)) { | |
8704 fail(runString); | |
8705 return; | |
8706 } | |
8707 // (1,16) == 256 | |
8708 runString = "(1,16)"; | |
8709 if (256 != jtt.optimize.BC_imul_16.test(1, 16)) { | |
8710 fail(runString); | |
8711 return; | |
8712 } | |
8713 // (1,17) == 272 | |
8714 runString = "(1,17)"; | |
8715 if (272 != jtt.optimize.BC_imul_16.test(1, 17)) { | |
8716 fail(runString); | |
8717 return; | |
8718 } | |
8719 // (1,-1) == -16 | |
8720 runString = "(1,-1)"; | |
8721 if (-16 != jtt.optimize.BC_imul_16.test(1, -1)) { | |
8722 fail(runString); | |
8723 return; | |
8724 } | |
8725 // (1,-16) == -256 | |
8726 runString = "(1,-16)"; | |
8727 if (-256 != jtt.optimize.BC_imul_16.test(1, -16)) { | |
8728 fail(runString); | |
8729 return; | |
8730 } | |
8731 // (1,-17) == -272 | |
8732 runString = "(1,-17)"; | |
8733 if (-272 != jtt.optimize.BC_imul_16.test(1, -17)) { | |
8734 fail(runString); | |
8735 return; | |
8736 } | |
8737 // (1,2147483647) == -16 | |
8738 runString = "(1,2147483647)"; | |
8739 if (-16 != jtt.optimize.BC_imul_16.test(1, 2147483647)) { | |
8740 fail(runString); | |
8741 return; | |
8742 } | |
8743 // (1,-2147483648) == 0 | |
8744 runString = "(1,-2147483648)"; | |
8745 if (0 != jtt.optimize.BC_imul_16.test(1, -2147483648)) { | |
8746 fail(runString); | |
8747 return; | |
8748 } | |
8749 } catch (Throwable t) { | |
8750 fail(runString, t); | |
8751 return; | |
8752 } | |
8753 pass(); | |
8754 } | |
8755 | |
8756 static void jtt_optimize_BC_imul_4() { | |
8757 begin("jtt.optimize.BC_imul_4"); | |
8758 String runString = null; | |
8759 try { | |
8760 // (0) == 0 | |
8761 runString = "(0)"; | |
8762 if (0 != jtt.optimize.BC_imul_4.test(0)) { | |
8763 fail(runString); | |
8764 return; | |
8765 } | |
8766 // (4) == 16 | |
8767 runString = "(4)"; | |
8768 if (16 != jtt.optimize.BC_imul_4.test(4)) { | |
8769 fail(runString); | |
8770 return; | |
8771 } | |
8772 // (5) == 20 | |
8773 runString = "(5)"; | |
8774 if (20 != jtt.optimize.BC_imul_4.test(5)) { | |
8775 fail(runString); | |
8776 return; | |
8777 } | |
8778 // (-1) == -4 | |
8779 runString = "(-1)"; | |
8780 if (-4 != jtt.optimize.BC_imul_4.test(-1)) { | |
8781 fail(runString); | |
8782 return; | |
8783 } | |
8784 // (-4) == -16 | |
8785 runString = "(-4)"; | |
8786 if (-16 != jtt.optimize.BC_imul_4.test(-4)) { | |
8787 fail(runString); | |
8788 return; | |
8789 } | |
8790 // (-5) == -20 | |
8791 runString = "(-5)"; | |
8792 if (-20 != jtt.optimize.BC_imul_4.test(-5)) { | |
8793 fail(runString); | |
8794 return; | |
8795 } | |
8796 // (-256) == -1024 | |
8797 runString = "(-256)"; | |
8798 if (-1024 != jtt.optimize.BC_imul_4.test(-256)) { | |
8799 fail(runString); | |
8800 return; | |
8801 } | |
8802 } catch (Throwable t) { | |
8803 fail(runString, t); | |
8804 return; | |
8805 } | |
8806 pass(); | |
8807 } | |
8808 | |
8809 static void jtt_optimize_BC_ldiv_16() { | |
8810 begin("jtt.optimize.BC_ldiv_16"); | |
8811 String runString = null; | |
8812 try { | |
8813 // (0) == 0 | |
8814 runString = "(0)"; | |
8815 if (0L != jtt.optimize.BC_ldiv_16.test(0L)) { | |
8816 fail(runString); | |
8817 return; | |
8818 } | |
8819 // (16) == 1 | |
8820 runString = "(16)"; | |
8821 if (1L != jtt.optimize.BC_ldiv_16.test(16L)) { | |
8822 fail(runString); | |
8823 return; | |
8824 } | |
8825 // (17) == 1 | |
8826 runString = "(17)"; | |
8827 if (1L != jtt.optimize.BC_ldiv_16.test(17L)) { | |
8828 fail(runString); | |
8829 return; | |
8830 } | |
8831 // (-1) == 0 | |
8832 runString = "(-1)"; | |
8833 if (0L != jtt.optimize.BC_ldiv_16.test(-1L)) { | |
8834 fail(runString); | |
8835 return; | |
8836 } | |
8837 // (-16) == -1 | |
8838 runString = "(-16)"; | |
8839 if (-1L != jtt.optimize.BC_ldiv_16.test(-16L)) { | |
8840 fail(runString); | |
8841 return; | |
8842 } | |
8843 // (-17) == -1 | |
8844 runString = "(-17)"; | |
8845 if (-1L != jtt.optimize.BC_ldiv_16.test(-17L)) { | |
8846 fail(runString); | |
8847 return; | |
8848 } | |
8849 // (-1024) == -64 | |
8850 runString = "(-1024)"; | |
8851 if (-64L != jtt.optimize.BC_ldiv_16.test(-1024L)) { | |
8852 fail(runString); | |
8853 return; | |
8854 } | |
8855 } catch (Throwable t) { | |
8856 fail(runString, t); | |
8857 return; | |
8858 } | |
8859 pass(); | |
8860 } | |
8861 | |
8862 static void jtt_optimize_BC_ldiv_4() { | |
8863 begin("jtt.optimize.BC_ldiv_4"); | |
8864 String runString = null; | |
8865 try { | |
8866 // (0) == 0 | |
8867 runString = "(0)"; | |
8868 if (0L != jtt.optimize.BC_ldiv_4.test(0L)) { | |
8869 fail(runString); | |
8870 return; | |
8871 } | |
8872 // (4) == 1 | |
8873 runString = "(4)"; | |
8874 if (1L != jtt.optimize.BC_ldiv_4.test(4L)) { | |
8875 fail(runString); | |
8876 return; | |
8877 } | |
8878 // (5) == 1 | |
8879 runString = "(5)"; | |
8880 if (1L != jtt.optimize.BC_ldiv_4.test(5L)) { | |
8881 fail(runString); | |
8882 return; | |
8883 } | |
8884 // (-1) == 0 | |
8885 runString = "(-1)"; | |
8886 if (0L != jtt.optimize.BC_ldiv_4.test(-1L)) { | |
8887 fail(runString); | |
8888 return; | |
8889 } | |
8890 // (-4) == -1 | |
8891 runString = "(-4)"; | |
8892 if (-1L != jtt.optimize.BC_ldiv_4.test(-4L)) { | |
8893 fail(runString); | |
8894 return; | |
8895 } | |
8896 // (-5) == -1 | |
8897 runString = "(-5)"; | |
8898 if (-1L != jtt.optimize.BC_ldiv_4.test(-5L)) { | |
8899 fail(runString); | |
8900 return; | |
8901 } | |
8902 // (-256) == -64 | |
8903 runString = "(-256)"; | |
8904 if (-64L != jtt.optimize.BC_ldiv_4.test(-256L)) { | |
8905 fail(runString); | |
8906 return; | |
8907 } | |
8908 } catch (Throwable t) { | |
8909 fail(runString, t); | |
8910 return; | |
8911 } | |
8912 pass(); | |
8913 } | |
8914 | |
8915 static void jtt_optimize_BC_lmul_16() { | |
8916 begin("jtt.optimize.BC_lmul_16"); | |
8917 String runString = null; | |
8918 try { | |
8919 // (0) == 0 | |
8920 runString = "(0)"; | |
8921 if (0L != jtt.optimize.BC_lmul_16.test(0L)) { | |
8922 fail(runString); | |
8923 return; | |
8924 } | |
8925 // (16) == 256 | |
8926 runString = "(16)"; | |
8927 if (256L != jtt.optimize.BC_lmul_16.test(16L)) { | |
8928 fail(runString); | |
8929 return; | |
8930 } | |
8931 // (17) == 272 | |
8932 runString = "(17)"; | |
8933 if (272L != jtt.optimize.BC_lmul_16.test(17L)) { | |
8934 fail(runString); | |
8935 return; | |
8936 } | |
8937 // (-1) == -16 | |
8938 runString = "(-1)"; | |
8939 if (-16L != jtt.optimize.BC_lmul_16.test(-1L)) { | |
8940 fail(runString); | |
8941 return; | |
8942 } | |
8943 // (-16) == -256 | |
8944 runString = "(-16)"; | |
8945 if (-256L != jtt.optimize.BC_lmul_16.test(-16L)) { | |
8946 fail(runString); | |
8947 return; | |
8948 } | |
8949 // (-17) == -272 | |
8950 runString = "(-17)"; | |
8951 if (-272L != jtt.optimize.BC_lmul_16.test(-17L)) { | |
8952 fail(runString); | |
8953 return; | |
8954 } | |
8955 // (-1024) == -16384 | |
8956 runString = "(-1024)"; | |
8957 if (-16384L != jtt.optimize.BC_lmul_16.test(-1024L)) { | |
8958 fail(runString); | |
8959 return; | |
8960 } | |
8961 } catch (Throwable t) { | |
8962 fail(runString, t); | |
8963 return; | |
8964 } | |
8965 pass(); | |
8966 } | |
8967 | |
8968 static void jtt_optimize_BC_lmul_4() { | |
8969 begin("jtt.optimize.BC_lmul_4"); | |
8970 String runString = null; | |
8971 try { | |
8972 // (0) == 0 | |
8973 runString = "(0)"; | |
8974 if (0L != jtt.optimize.BC_lmul_4.test(0L)) { | |
8975 fail(runString); | |
8976 return; | |
8977 } | |
8978 // (4) == 16 | |
8979 runString = "(4)"; | |
8980 if (16L != jtt.optimize.BC_lmul_4.test(4L)) { | |
8981 fail(runString); | |
8982 return; | |
8983 } | |
8984 // (5) == 20 | |
8985 runString = "(5)"; | |
8986 if (20L != jtt.optimize.BC_lmul_4.test(5L)) { | |
8987 fail(runString); | |
8988 return; | |
8989 } | |
8990 // (-1) == -4 | |
8991 runString = "(-1)"; | |
8992 if (-4L != jtt.optimize.BC_lmul_4.test(-1L)) { | |
8993 fail(runString); | |
8994 return; | |
8995 } | |
8996 // (-4) == -16 | |
8997 runString = "(-4)"; | |
8998 if (-16L != jtt.optimize.BC_lmul_4.test(-4L)) { | |
8999 fail(runString); | |
9000 return; | |
9001 } | |
9002 // (-5) == -20 | |
9003 runString = "(-5)"; | |
9004 if (-20L != jtt.optimize.BC_lmul_4.test(-5L)) { | |
9005 fail(runString); | |
9006 return; | |
9007 } | |
9008 // (-256) == -1024 | |
9009 runString = "(-256)"; | |
9010 if (-1024L != jtt.optimize.BC_lmul_4.test(-256L)) { | |
9011 fail(runString); | |
9012 return; | |
9013 } | |
9014 } catch (Throwable t) { | |
9015 fail(runString, t); | |
9016 return; | |
9017 } | |
9018 pass(); | |
9019 } | |
9020 | |
9021 static void jtt_optimize_BC_lshr_C16() { | |
9022 begin("jtt.optimize.BC_lshr_C16"); | |
9023 String runString = null; | |
9024 try { | |
9025 // (87224824140) == 1330945 | |
9026 runString = "(87224824140)"; | |
9027 if (1330945L != jtt.optimize.BC_lshr_C16.test(87224824140L)) { | |
9028 fail(runString); | |
9029 return; | |
9030 } | |
9031 } catch (Throwable t) { | |
9032 fail(runString, t); | |
9033 return; | |
9034 } | |
9035 pass(); | |
9036 } | |
9037 | |
9038 static void jtt_optimize_BC_lshr_C24() { | |
9039 begin("jtt.optimize.BC_lshr_C24"); | |
9040 String runString = null; | |
9041 try { | |
9042 // (87224824140) == 5199 | |
9043 runString = "(87224824140)"; | |
9044 if (5199L != jtt.optimize.BC_lshr_C24.test(87224824140L)) { | |
9045 fail(runString); | |
9046 return; | |
9047 } | |
9048 } catch (Throwable t) { | |
9049 fail(runString, t); | |
9050 return; | |
9051 } | |
9052 pass(); | |
9053 } | |
9054 | |
9055 static void jtt_optimize_BC_lshr_C32() { | |
9056 begin("jtt.optimize.BC_lshr_C32"); | |
9057 String runString = null; | |
9058 try { | |
9059 // (87224824140) == 20 | |
9060 runString = "(87224824140)"; | |
9061 if (20L != jtt.optimize.BC_lshr_C32.test(87224824140L)) { | |
9062 fail(runString); | |
9063 return; | |
9064 } | |
9065 } catch (Throwable t) { | |
9066 fail(runString, t); | |
9067 return; | |
9068 } | |
9069 pass(); | |
9070 } | |
9071 | |
9072 static void jtt_optimize_BlockSkip01() { | |
9073 begin("jtt.optimize.BlockSkip01"); | |
9074 String runString = null; | |
9075 try { | |
9076 // (0) == true | |
9077 runString = "(0)"; | |
9078 if (true != jtt.optimize.BlockSkip01.test(0)) { | |
9079 fail(runString); | |
9080 return; | |
9081 } | |
9082 // (1) == true | |
9083 runString = "(1)"; | |
9084 if (true != jtt.optimize.BlockSkip01.test(1)) { | |
9085 fail(runString); | |
9086 return; | |
9087 } | |
9088 // (2) == true | |
9089 runString = "(2)"; | |
9090 if (true != jtt.optimize.BlockSkip01.test(2)) { | |
9091 fail(runString); | |
9092 return; | |
9093 } | |
9094 // (3) == false | |
9095 runString = "(3)"; | |
9096 if (false != jtt.optimize.BlockSkip01.test(3)) { | |
9097 fail(runString); | |
9098 return; | |
9099 } | |
9100 // (4) == false | |
9101 runString = "(4)"; | |
9102 if (false != jtt.optimize.BlockSkip01.test(4)) { | |
9103 fail(runString); | |
9104 return; | |
9105 } | |
9106 } catch (Throwable t) { | |
9107 fail(runString, t); | |
9108 return; | |
9109 } | |
9110 pass(); | |
9111 } | |
9112 | |
9113 static void jtt_optimize_Cmov01() { | |
9114 begin("jtt.optimize.Cmov01"); | |
9115 String runString = null; | |
9116 try { | |
9117 // (-1,-1) == true | |
9118 runString = "(-1,-1)"; | |
9119 if (true != jtt.optimize.Cmov01.test(-1, -1)) { | |
9120 fail(runString); | |
9121 return; | |
9122 } | |
9123 // (1,10) == true | |
9124 runString = "(1,10)"; | |
9125 if (true != jtt.optimize.Cmov01.test(1, 10)) { | |
9126 fail(runString); | |
9127 return; | |
9128 } | |
9129 // (1,0) == false | |
9130 runString = "(1,0)"; | |
9131 if (false != jtt.optimize.Cmov01.test(1, 0)) { | |
9132 fail(runString); | |
9133 return; | |
9134 } | |
9135 } catch (Throwable t) { | |
9136 fail(runString, t); | |
9137 return; | |
9138 } | |
9139 pass(); | |
9140 } | |
9141 | |
9142 static void jtt_optimize_DeadCode01() { | |
9143 begin("jtt.optimize.DeadCode01"); | |
9144 String runString = null; | |
9145 try { | |
9146 // (0) == 4 | |
9147 runString = "(0)"; | |
9148 if (4 != jtt.optimize.DeadCode01.test(0)) { | |
9149 fail(runString); | |
9150 return; | |
9151 } | |
9152 // (1) == 5 | |
9153 runString = "(1)"; | |
9154 if (5 != jtt.optimize.DeadCode01.test(1)) { | |
9155 fail(runString); | |
9156 return; | |
9157 } | |
9158 // (2) == 6 | |
9159 runString = "(2)"; | |
9160 if (6 != jtt.optimize.DeadCode01.test(2)) { | |
9161 fail(runString); | |
9162 return; | |
9163 } | |
9164 // (3) == 4 | |
9165 runString = "(3)"; | |
9166 if (4 != jtt.optimize.DeadCode01.test(3)) { | |
9167 fail(runString); | |
9168 return; | |
9169 } | |
9170 // (4) == 5 | |
9171 runString = "(4)"; | |
9172 if (5 != jtt.optimize.DeadCode01.test(4)) { | |
9173 fail(runString); | |
9174 return; | |
9175 } | |
9176 // (6) == 7 | |
9177 runString = "(6)"; | |
9178 if (7 != jtt.optimize.DeadCode01.test(6)) { | |
9179 fail(runString); | |
9180 return; | |
9181 } | |
9182 } catch (Throwable t) { | |
9183 fail(runString, t); | |
9184 return; | |
9185 } | |
9186 pass(); | |
9187 } | |
9188 | |
9189 static void jtt_optimize_Fold_Cast01() { | |
9190 begin("jtt.optimize.Fold_Cast01"); | |
9191 String runString = null; | |
9192 try { | |
9193 // (0) == 9 | |
9194 runString = "(0)"; | |
9195 if (9 != jtt.optimize.Fold_Cast01.test(0)) { | |
9196 fail(runString); | |
9197 return; | |
9198 } | |
9199 // (1) == 9 | |
9200 runString = "(1)"; | |
9201 if (9 != jtt.optimize.Fold_Cast01.test(1)) { | |
9202 fail(runString); | |
9203 return; | |
9204 } | |
9205 // (2) == !java.lang.NullPointerException | |
9206 try { | |
9207 runString = "(2)"; | |
9208 jtt.optimize.Fold_Cast01.test(2); | |
9209 fail(runString); | |
9210 return; | |
9211 } catch (Throwable e) { | |
9212 if (e.getClass() != java.lang.NullPointerException.class) { | |
9213 fail(runString, e); | |
9214 return; | |
9215 } | |
9216 } | |
9217 } catch (Throwable t) { | |
9218 fail(runString, t); | |
9219 return; | |
9220 } | |
9221 pass(); | |
9222 } | |
9223 | |
9224 static void jtt_optimize_Fold_Convert01() { | |
9225 begin("jtt.optimize.Fold_Convert01"); | |
9226 String runString = null; | |
9227 try { | |
9228 // (0) == -128 | |
9229 runString = "(0)"; | |
9230 if (-128 != jtt.optimize.Fold_Convert01.test(0)) { | |
9231 fail(runString); | |
9232 return; | |
9233 } | |
9234 // (1) == -32768 | |
9235 runString = "(1)"; | |
9236 if (-32768 != jtt.optimize.Fold_Convert01.test(1)) { | |
9237 fail(runString); | |
9238 return; | |
9239 } | |
9240 // (2) == 65535 | |
9241 runString = "(2)"; | |
9242 if (65535 != jtt.optimize.Fold_Convert01.test(2)) { | |
9243 fail(runString); | |
9244 return; | |
9245 } | |
9246 } catch (Throwable t) { | |
9247 fail(runString, t); | |
9248 return; | |
9249 } | |
9250 pass(); | |
9251 } | |
9252 | |
9253 static void jtt_optimize_Fold_Convert02() { | |
9254 begin("jtt.optimize.Fold_Convert02"); | |
9255 String runString = null; | |
9256 try { | |
9257 // (0) == -2147483648 | |
9258 runString = "(0)"; | |
9259 if (-2147483648L != jtt.optimize.Fold_Convert02.test(0)) { | |
9260 fail(runString); | |
9261 return; | |
9262 } | |
9263 // (1) == -33 | |
9264 runString = "(1)"; | |
9265 if (-33L != jtt.optimize.Fold_Convert02.test(1)) { | |
9266 fail(runString); | |
9267 return; | |
9268 } | |
9269 // (2) == -78 | |
9270 runString = "(2)"; | |
9271 if (-78L != jtt.optimize.Fold_Convert02.test(2)) { | |
9272 fail(runString); | |
9273 return; | |
9274 } | |
9275 } catch (Throwable t) { | |
9276 fail(runString, t); | |
9277 return; | |
9278 } | |
9279 pass(); | |
9280 } | |
9281 | |
9282 static void jtt_optimize_Fold_Convert03() { | |
9283 begin("jtt.optimize.Fold_Convert03"); | |
9284 String runString = null; | |
9285 try { | |
9286 // (0) == 1024.0 | |
9287 runString = "(0)"; | |
9288 if (1024.0f != jtt.optimize.Fold_Convert03.test(0)) { | |
9289 fail(runString); | |
9290 return; | |
9291 } | |
9292 // (1) == -33.0 | |
9293 runString = "(1)"; | |
9294 if (-33.0f != jtt.optimize.Fold_Convert03.test(1)) { | |
9295 fail(runString); | |
9296 return; | |
9297 } | |
9298 // (2) == -78.1 | |
9299 runString = "(2)"; | |
9300 if (-78.1f != jtt.optimize.Fold_Convert03.test(2)) { | |
9301 fail(runString); | |
9302 return; | |
9303 } | |
9304 } catch (Throwable t) { | |
9305 fail(runString, t); | |
9306 return; | |
9307 } | |
9308 pass(); | |
9309 } | |
9310 | |
9311 static void jtt_optimize_Fold_Convert04() { | |
9312 begin("jtt.optimize.Fold_Convert04"); | |
9313 String runString = null; | |
9314 try { | |
9315 // (0) == 1024.0 | |
9316 runString = "(0)"; | |
9317 if (1024.0 != jtt.optimize.Fold_Convert04.test(0)) { | |
9318 fail(runString); | |
9319 return; | |
9320 } | |
9321 // (1) == -1.25 | |
9322 runString = "(1)"; | |
9323 if (-1.25 != jtt.optimize.Fold_Convert04.test(1)) { | |
9324 fail(runString); | |
9325 return; | |
9326 } | |
9327 } catch (Throwable t) { | |
9328 fail(runString, t); | |
9329 return; | |
9330 } | |
9331 pass(); | |
9332 } | |
9333 | |
9334 static void jtt_optimize_Fold_Double01() { | |
9335 begin("jtt.optimize.Fold_Double01"); | |
9336 String runString = null; | |
9337 try { | |
9338 // (0.0) == 10.0 | |
9339 runString = "(0.0)"; | |
9340 if (10.0 != jtt.optimize.Fold_Double01.test(0.0)) { | |
9341 fail(runString); | |
9342 return; | |
9343 } | |
9344 // (1.0) == 11.0 | |
9345 runString = "(1.0)"; | |
9346 if (11.0 != jtt.optimize.Fold_Double01.test(1.0)) { | |
9347 fail(runString); | |
9348 return; | |
9349 } | |
9350 // (2.0) == 12.0 | |
9351 runString = "(2.0)"; | |
9352 if (12.0 != jtt.optimize.Fold_Double01.test(2.0)) { | |
9353 fail(runString); | |
9354 return; | |
9355 } | |
9356 // (3.0) == 13.0 | |
9357 runString = "(3.0)"; | |
9358 if (13.0 != jtt.optimize.Fold_Double01.test(3.0)) { | |
9359 fail(runString); | |
9360 return; | |
9361 } | |
9362 // (4.0) == 14.0 | |
9363 runString = "(4.0)"; | |
9364 if (14.0 != jtt.optimize.Fold_Double01.test(4.0)) { | |
9365 fail(runString); | |
9366 return; | |
9367 } | |
9368 } catch (Throwable t) { | |
9369 fail(runString, t); | |
9370 return; | |
9371 } | |
9372 pass(); | |
9373 } | |
9374 | |
9375 static void jtt_optimize_Fold_Double02() { | |
9376 begin("jtt.optimize.Fold_Double02"); | |
9377 String runString = null; | |
9378 try { | |
9379 // (0) == true | |
9380 runString = "(0)"; | |
9381 if (true != jtt.optimize.Fold_Double02.test(0)) { | |
9382 fail(runString); | |
9383 return; | |
9384 } | |
9385 // (1) == true | |
9386 runString = "(1)"; | |
9387 if (true != jtt.optimize.Fold_Double02.test(1)) { | |
9388 fail(runString); | |
9389 return; | |
9390 } | |
9391 // (2) == true | |
9392 runString = "(2)"; | |
9393 if (true != jtt.optimize.Fold_Double02.test(2)) { | |
9394 fail(runString); | |
9395 return; | |
9396 } | |
9397 // (3) == false | |
9398 runString = "(3)"; | |
9399 if (false != jtt.optimize.Fold_Double02.test(3)) { | |
9400 fail(runString); | |
9401 return; | |
9402 } | |
9403 // (4) == false | |
9404 runString = "(4)"; | |
9405 if (false != jtt.optimize.Fold_Double02.test(4)) { | |
9406 fail(runString); | |
9407 return; | |
9408 } | |
9409 // (5) == false | |
9410 runString = "(5)"; | |
9411 if (false != jtt.optimize.Fold_Double02.test(5)) { | |
9412 fail(runString); | |
9413 return; | |
9414 } | |
9415 } catch (Throwable t) { | |
9416 fail(runString, t); | |
9417 return; | |
9418 } | |
9419 pass(); | |
9420 } | |
9421 | |
9422 static void jtt_optimize_Fold_Float01() { | |
9423 begin("jtt.optimize.Fold_Float01"); | |
9424 String runString = null; | |
9425 try { | |
9426 // (0.0) == 10.0 | |
9427 runString = "(0.0)"; | |
9428 if (10.0f != jtt.optimize.Fold_Float01.test(0.0f)) { | |
9429 fail(runString); | |
9430 return; | |
9431 } | |
9432 // (1.0) == 11.0 | |
9433 runString = "(1.0)"; | |
9434 if (11.0f != jtt.optimize.Fold_Float01.test(1.0f)) { | |
9435 fail(runString); | |
9436 return; | |
9437 } | |
9438 // (2.0) == 12.0 | |
9439 runString = "(2.0)"; | |
9440 if (12.0f != jtt.optimize.Fold_Float01.test(2.0f)) { | |
9441 fail(runString); | |
9442 return; | |
9443 } | |
9444 // (3.0) == 13.0 | |
9445 runString = "(3.0)"; | |
9446 if (13.0f != jtt.optimize.Fold_Float01.test(3.0f)) { | |
9447 fail(runString); | |
9448 return; | |
9449 } | |
9450 // (4.0) == 14.0 | |
9451 runString = "(4.0)"; | |
9452 if (14.0f != jtt.optimize.Fold_Float01.test(4.0f)) { | |
9453 fail(runString); | |
9454 return; | |
9455 } | |
9456 } catch (Throwable t) { | |
9457 fail(runString, t); | |
9458 return; | |
9459 } | |
9460 pass(); | |
9461 } | |
9462 | |
9463 static void jtt_optimize_Fold_Float02() { | |
9464 begin("jtt.optimize.Fold_Float02"); | |
9465 String runString = null; | |
9466 try { | |
9467 // (0) == true | |
9468 runString = "(0)"; | |
9469 if (true != jtt.optimize.Fold_Float02.test(0)) { | |
9470 fail(runString); | |
9471 return; | |
9472 } | |
9473 // (1) == true | |
9474 runString = "(1)"; | |
9475 if (true != jtt.optimize.Fold_Float02.test(1)) { | |
9476 fail(runString); | |
9477 return; | |
9478 } | |
9479 // (2) == true | |
9480 runString = "(2)"; | |
9481 if (true != jtt.optimize.Fold_Float02.test(2)) { | |
9482 fail(runString); | |
9483 return; | |
9484 } | |
9485 // (3) == false | |
9486 runString = "(3)"; | |
9487 if (false != jtt.optimize.Fold_Float02.test(3)) { | |
9488 fail(runString); | |
9489 return; | |
9490 } | |
9491 // (4) == false | |
9492 runString = "(4)"; | |
9493 if (false != jtt.optimize.Fold_Float02.test(4)) { | |
9494 fail(runString); | |
9495 return; | |
9496 } | |
9497 // (5) == false | |
9498 runString = "(5)"; | |
9499 if (false != jtt.optimize.Fold_Float02.test(5)) { | |
9500 fail(runString); | |
9501 return; | |
9502 } | |
9503 } catch (Throwable t) { | |
9504 fail(runString, t); | |
9505 return; | |
9506 } | |
9507 pass(); | |
9508 } | |
9509 | |
9510 static void jtt_optimize_Fold_InstanceOf01() { | |
9511 begin("jtt.optimize.Fold_InstanceOf01"); | |
9512 String runString = null; | |
9513 try { | |
9514 // (0) == true | |
9515 runString = "(0)"; | |
9516 if (true != jtt.optimize.Fold_InstanceOf01.test(0)) { | |
9517 fail(runString); | |
9518 return; | |
9519 } | |
9520 // (1) == true | |
9521 runString = "(1)"; | |
9522 if (true != jtt.optimize.Fold_InstanceOf01.test(1)) { | |
9523 fail(runString); | |
9524 return; | |
9525 } | |
9526 // (2) == false | |
9527 runString = "(2)"; | |
9528 if (false != jtt.optimize.Fold_InstanceOf01.test(2)) { | |
9529 fail(runString); | |
9530 return; | |
9531 } | |
9532 } catch (Throwable t) { | |
9533 fail(runString, t); | |
9534 return; | |
9535 } | |
9536 pass(); | |
9537 } | |
9538 | |
9539 static void jtt_optimize_Fold_Int01() { | |
9540 begin("jtt.optimize.Fold_Int01"); | |
9541 String runString = null; | |
9542 try { | |
9543 // (0) == 10 | |
9544 runString = "(0)"; | |
9545 if (10 != jtt.optimize.Fold_Int01.test(0)) { | |
9546 fail(runString); | |
9547 return; | |
9548 } | |
9549 // (1) == 11 | |
9550 runString = "(1)"; | |
9551 if (11 != jtt.optimize.Fold_Int01.test(1)) { | |
9552 fail(runString); | |
9553 return; | |
9554 } | |
9555 // (2) == 12 | |
9556 runString = "(2)"; | |
9557 if (12 != jtt.optimize.Fold_Int01.test(2)) { | |
9558 fail(runString); | |
9559 return; | |
9560 } | |
9561 // (3) == 13 | |
9562 runString = "(3)"; | |
9563 if (13 != jtt.optimize.Fold_Int01.test(3)) { | |
9564 fail(runString); | |
9565 return; | |
9566 } | |
9567 // (4) == 14 | |
9568 runString = "(4)"; | |
9569 if (14 != jtt.optimize.Fold_Int01.test(4)) { | |
9570 fail(runString); | |
9571 return; | |
9572 } | |
9573 // (5) == 15 | |
9574 runString = "(5)"; | |
9575 if (15 != jtt.optimize.Fold_Int01.test(5)) { | |
9576 fail(runString); | |
9577 return; | |
9578 } | |
9579 // (6) == 16 | |
9580 runString = "(6)"; | |
9581 if (16 != jtt.optimize.Fold_Int01.test(6)) { | |
9582 fail(runString); | |
9583 return; | |
9584 } | |
9585 // (7) == 17 | |
9586 runString = "(7)"; | |
9587 if (17 != jtt.optimize.Fold_Int01.test(7)) { | |
9588 fail(runString); | |
9589 return; | |
9590 } | |
9591 } catch (Throwable t) { | |
9592 fail(runString, t); | |
9593 return; | |
9594 } | |
9595 pass(); | |
9596 } | |
9597 | |
9598 static void jtt_optimize_Fold_Int02() { | |
9599 begin("jtt.optimize.Fold_Int02"); | |
9600 String runString = null; | |
9601 try { | |
9602 // (0) == true | |
9603 runString = "(0)"; | |
9604 if (true != jtt.optimize.Fold_Int02.test(0)) { | |
9605 fail(runString); | |
9606 return; | |
9607 } | |
9608 // (1) == true | |
9609 runString = "(1)"; | |
9610 if (true != jtt.optimize.Fold_Int02.test(1)) { | |
9611 fail(runString); | |
9612 return; | |
9613 } | |
9614 // (2) == true | |
9615 runString = "(2)"; | |
9616 if (true != jtt.optimize.Fold_Int02.test(2)) { | |
9617 fail(runString); | |
9618 return; | |
9619 } | |
9620 // (3) == false | |
9621 runString = "(3)"; | |
9622 if (false != jtt.optimize.Fold_Int02.test(3)) { | |
9623 fail(runString); | |
9624 return; | |
9625 } | |
9626 // (4) == false | |
9627 runString = "(4)"; | |
9628 if (false != jtt.optimize.Fold_Int02.test(4)) { | |
9629 fail(runString); | |
9630 return; | |
9631 } | |
9632 // (5) == false | |
9633 runString = "(5)"; | |
9634 if (false != jtt.optimize.Fold_Int02.test(5)) { | |
9635 fail(runString); | |
9636 return; | |
9637 } | |
9638 } catch (Throwable t) { | |
9639 fail(runString, t); | |
9640 return; | |
9641 } | |
9642 pass(); | |
9643 } | |
9644 | |
9645 static void jtt_optimize_Fold_Long01() { | |
9646 begin("jtt.optimize.Fold_Long01"); | |
9647 String runString = null; | |
9648 try { | |
9649 // (0) == 10 | |
9650 runString = "(0)"; | |
9651 if (10L != jtt.optimize.Fold_Long01.test(0)) { | |
9652 fail(runString); | |
9653 return; | |
9654 } | |
9655 // (1) == 11 | |
9656 runString = "(1)"; | |
9657 if (11L != jtt.optimize.Fold_Long01.test(1)) { | |
9658 fail(runString); | |
9659 return; | |
9660 } | |
9661 // (2) == 12 | |
9662 runString = "(2)"; | |
9663 if (12L != jtt.optimize.Fold_Long01.test(2)) { | |
9664 fail(runString); | |
9665 return; | |
9666 } | |
9667 // (3) == 13 | |
9668 runString = "(3)"; | |
9669 if (13L != jtt.optimize.Fold_Long01.test(3)) { | |
9670 fail(runString); | |
9671 return; | |
9672 } | |
9673 // (4) == 14 | |
9674 runString = "(4)"; | |
9675 if (14L != jtt.optimize.Fold_Long01.test(4)) { | |
9676 fail(runString); | |
9677 return; | |
9678 } | |
9679 // (5) == 15 | |
9680 runString = "(5)"; | |
9681 if (15L != jtt.optimize.Fold_Long01.test(5)) { | |
9682 fail(runString); | |
9683 return; | |
9684 } | |
9685 // (6) == 16 | |
9686 runString = "(6)"; | |
9687 if (16L != jtt.optimize.Fold_Long01.test(6)) { | |
9688 fail(runString); | |
9689 return; | |
9690 } | |
9691 // (7) == 17 | |
9692 runString = "(7)"; | |
9693 if (17L != jtt.optimize.Fold_Long01.test(7)) { | |
9694 fail(runString); | |
9695 return; | |
9696 } | |
9697 } catch (Throwable t) { | |
9698 fail(runString, t); | |
9699 return; | |
9700 } | |
9701 pass(); | |
9702 } | |
9703 | |
9704 static void jtt_optimize_Fold_Long02() { | |
9705 begin("jtt.optimize.Fold_Long02"); | |
9706 String runString = null; | |
9707 try { | |
9708 // (0) == true | |
9709 runString = "(0)"; | |
9710 if (true != jtt.optimize.Fold_Long02.test(0)) { | |
9711 fail(runString); | |
9712 return; | |
9713 } | |
9714 // (1) == true | |
9715 runString = "(1)"; | |
9716 if (true != jtt.optimize.Fold_Long02.test(1)) { | |
9717 fail(runString); | |
9718 return; | |
9719 } | |
9720 // (2) == true | |
9721 runString = "(2)"; | |
9722 if (true != jtt.optimize.Fold_Long02.test(2)) { | |
9723 fail(runString); | |
9724 return; | |
9725 } | |
9726 // (3) == false | |
9727 runString = "(3)"; | |
9728 if (false != jtt.optimize.Fold_Long02.test(3)) { | |
9729 fail(runString); | |
9730 return; | |
9731 } | |
9732 // (4) == false | |
9733 runString = "(4)"; | |
9734 if (false != jtt.optimize.Fold_Long02.test(4)) { | |
9735 fail(runString); | |
9736 return; | |
9737 } | |
9738 // (5) == false | |
9739 runString = "(5)"; | |
9740 if (false != jtt.optimize.Fold_Long02.test(5)) { | |
9741 fail(runString); | |
9742 return; | |
9743 } | |
9744 } catch (Throwable t) { | |
9745 fail(runString, t); | |
9746 return; | |
9747 } | |
9748 pass(); | |
9749 } | |
9750 | |
9751 static void jtt_optimize_Fold_Math01() { | |
9752 begin("jtt.optimize.Fold_Math01"); | |
9753 String runString = null; | |
9754 try { | |
9755 // (0) == 10.0 | |
9756 runString = "(0)"; | |
9757 if (10.0 != jtt.optimize.Fold_Math01.test(0)) { | |
9758 fail(runString); | |
9759 return; | |
9760 } | |
9761 // (1) == 0.14943813247359922 | |
9762 runString = "(1)"; | |
9763 if (0.14943813247359922 != jtt.optimize.Fold_Math01.test(1)) { | |
9764 fail(runString); | |
9765 return; | |
9766 } | |
9767 // (2) == 0.9887710779360422 | |
9768 runString = "(2)"; | |
9769 if (0.9887710779360422 != jtt.optimize.Fold_Math01.test(2)) { | |
9770 fail(runString); | |
9771 return; | |
9772 } | |
9773 // (3) == 0.15113521805829508 | |
9774 runString = "(3)"; | |
9775 if (0.15113521805829508 != jtt.optimize.Fold_Math01.test(3)) { | |
9776 fail(runString); | |
9777 return; | |
9778 } | |
9779 // (4) == 0.04834938665190287 | |
9780 runString = "(4)"; | |
9781 if (0.04834938665190287 != jtt.optimize.Fold_Math01.test(4)) { | |
9782 fail(runString); | |
9783 return; | |
9784 } | |
9785 // (5) == 12.0 | |
9786 runString = "(5)"; | |
9787 if (12.0 != jtt.optimize.Fold_Math01.test(5)) { | |
9788 fail(runString); | |
9789 return; | |
9790 } | |
9791 // (6) == 1.1474024528375417 | |
9792 runString = "(6)"; | |
9793 if (1.1474024528375417 != jtt.optimize.Fold_Math01.test(6)) { | |
9794 fail(runString); | |
9795 return; | |
9796 } | |
9797 // (7) == -0.8239087409443188 | |
9798 runString = "(7)"; | |
9799 if (-0.8239087409443188 != jtt.optimize.Fold_Math01.test(7)) { | |
9800 fail(runString); | |
9801 return; | |
9802 } | |
9803 // (8) == 106.62882057436371 | |
9804 runString = "(8)"; | |
9805 if (106.62882057436371 != jtt.optimize.Fold_Math01.test(8)) { | |
9806 fail(runString); | |
9807 return; | |
9808 } | |
9809 // (9) == 1.1474024528375417 | |
9810 runString = "(9)"; | |
9811 if (1.1474024528375417 != jtt.optimize.Fold_Math01.test(9)) { | |
9812 fail(runString); | |
9813 return; | |
9814 } | |
9815 // (10) == -1.0 | |
9816 runString = "(10)"; | |
9817 if (-1.0 != jtt.optimize.Fold_Math01.test(10)) { | |
9818 fail(runString); | |
9819 return; | |
9820 } | |
9821 // (11) == 2.0 | |
9822 runString = "(11)"; | |
9823 if (2.0 != jtt.optimize.Fold_Math01.test(11)) { | |
9824 fail(runString); | |
9825 return; | |
9826 } | |
9827 // (12) == 42.0 | |
9828 runString = "(12)"; | |
9829 if (42.0 != jtt.optimize.Fold_Math01.test(12)) { | |
9830 fail(runString); | |
9831 return; | |
9832 } | |
9833 } catch (Throwable t) { | |
9834 fail(runString, t); | |
9835 return; | |
9836 } | |
9837 pass(); | |
9838 } | |
9839 | |
9840 static void jtt_optimize_Inline01() { | |
9841 begin("jtt.optimize.Inline01"); | |
9842 String runString = null; | |
9843 try { | |
9844 // (0) == 2 | |
9845 runString = "(0)"; | |
9846 if (2 != jtt.optimize.Inline01.test(0)) { | |
9847 fail(runString); | |
9848 return; | |
9849 } | |
9850 // (1) == 3 | |
9851 runString = "(1)"; | |
9852 if (3 != jtt.optimize.Inline01.test(1)) { | |
9853 fail(runString); | |
9854 return; | |
9855 } | |
9856 } catch (Throwable t) { | |
9857 fail(runString, t); | |
9858 return; | |
9859 } | |
9860 pass(); | |
9861 } | |
9862 | |
9863 static void jtt_optimize_Inline02() { | |
9864 begin("jtt.optimize.Inline02"); | |
9865 String runString = null; | |
9866 try { | |
9867 // (0) == 2 | |
9868 runString = "(0)"; | |
9869 if (2 != jtt.optimize.Inline02.test(0)) { | |
9870 fail(runString); | |
9871 return; | |
9872 } | |
9873 // (1) == 5 | |
9874 runString = "(1)"; | |
9875 if (5 != jtt.optimize.Inline02.test(1)) { | |
9876 fail(runString); | |
9877 return; | |
9878 } | |
9879 // (2) == 8 | |
9880 runString = "(2)"; | |
9881 if (8 != jtt.optimize.Inline02.test(2)) { | |
9882 fail(runString); | |
9883 return; | |
9884 } | |
9885 } catch (Throwable t) { | |
9886 fail(runString, t); | |
9887 return; | |
9888 } | |
9889 pass(); | |
9890 } | |
9891 | |
9892 static void jtt_optimize_List_reorder_bug() { | |
9893 begin("jtt.optimize.List_reorder_bug"); | |
9894 String runString = null; | |
9895 try { | |
9896 // (0) == true | |
9897 runString = "(0)"; | |
9898 if (true != jtt.optimize.List_reorder_bug.test(0)) { | |
9899 fail(runString); | |
9900 return; | |
9901 } | |
9902 } catch (Throwable t) { | |
9903 fail(runString, t); | |
9904 return; | |
9905 } | |
9906 pass(); | |
9907 } | |
9908 | |
9909 static void jtt_optimize_NCE_01() { | |
9910 begin("jtt.optimize.NCE_01"); | |
9911 String runString = null; | |
9912 try { | |
9913 // (0) == 45 | |
9914 runString = "(0)"; | |
9915 if (45 != jtt.optimize.NCE_01.test(0)) { | |
9916 fail(runString); | |
9917 return; | |
9918 } | |
9919 } catch (Throwable t) { | |
9920 fail(runString, t); | |
9921 return; | |
9922 } | |
9923 pass(); | |
9924 } | |
9925 | |
9926 static void jtt_optimize_NCE_02() { | |
9927 begin("jtt.optimize.NCE_02"); | |
9928 String runString = null; | |
9929 try { | |
9930 // (0) == 23 | |
9931 runString = "(0)"; | |
9932 if (23 != jtt.optimize.NCE_02.test(0)) { | |
9933 fail(runString); | |
9934 return; | |
9935 } | |
9936 } catch (Throwable t) { | |
9937 fail(runString, t); | |
9938 return; | |
9939 } | |
9940 pass(); | |
9941 } | |
9942 | |
9943 static void jtt_optimize_NCE_03() { | |
9944 begin("jtt.optimize.NCE_03"); | |
9945 String runString = null; | |
9946 try { | |
9947 // (0) == 23 | |
9948 runString = "(0)"; | |
9949 if (23 != jtt.optimize.NCE_03.test(0)) { | |
9950 fail(runString); | |
9951 return; | |
9952 } | |
9953 } catch (Throwable t) { | |
9954 fail(runString, t); | |
9955 return; | |
9956 } | |
9957 pass(); | |
9958 } | |
9959 | |
9960 static void jtt_optimize_NCE_04() { | |
9961 begin("jtt.optimize.NCE_04"); | |
9962 String runString = null; | |
9963 try { | |
9964 // (0) == 23 | |
9965 runString = "(0)"; | |
9966 if (23 != jtt.optimize.NCE_04.test(0)) { | |
9967 fail(runString); | |
9968 return; | |
9969 } | |
9970 } catch (Throwable t) { | |
9971 fail(runString, t); | |
9972 return; | |
9973 } | |
9974 pass(); | |
9975 } | |
9976 | |
9977 static void jtt_optimize_NCE_FlowSensitive01() { | |
9978 begin("jtt.optimize.NCE_FlowSensitive01"); | |
9979 String runString = null; | |
9980 try { | |
9981 // (null) == null | |
9982 runString = "(null)"; | |
9983 if (null != jtt.optimize.NCE_FlowSensitive01.test(null)) { | |
9984 fail(runString); | |
9985 return; | |
9986 } | |
9987 // ("x") == "x" | |
9988 runString = "(\"x\")"; | |
9989 if (!"x".equals(jtt.optimize.NCE_FlowSensitive01.test("x"))) { | |
9990 fail(runString); | |
9991 return; | |
9992 } | |
9993 // ("yay") == "yay" | |
9994 runString = "(\"yay\")"; | |
9995 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive01.test("yay"))) { | |
9996 fail(runString); | |
9997 return; | |
9998 } | |
9999 } catch (Throwable t) { | |
10000 fail(runString, t); | |
10001 return; | |
10002 } | |
10003 pass(); | |
10004 } | |
10005 | |
10006 static void jtt_optimize_NCE_FlowSensitive02() { | |
10007 begin("jtt.optimize.NCE_FlowSensitive02"); | |
10008 String runString = null; | |
10009 try { | |
10010 // (null) == !java.lang.NullPointerException | |
10011 try { | |
10012 runString = "(null)"; | |
10013 jtt.optimize.NCE_FlowSensitive02.test(null); | |
10014 fail(runString); | |
10015 return; | |
10016 } catch (Throwable e) { | |
10017 if (e.getClass() != java.lang.NullPointerException.class) { | |
10018 fail(runString, e); | |
10019 return; | |
10020 } | |
10021 } | |
10022 // ("x") == "x" | |
10023 runString = "(\"x\")"; | |
10024 if (!"x".equals(jtt.optimize.NCE_FlowSensitive02.test("x"))) { | |
10025 fail(runString); | |
10026 return; | |
10027 } | |
10028 // ("yay") == "yay" | |
10029 runString = "(\"yay\")"; | |
10030 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive02.test("yay"))) { | |
10031 fail(runString); | |
10032 return; | |
10033 } | |
10034 } catch (Throwable t) { | |
10035 fail(runString, t); | |
10036 return; | |
10037 } | |
10038 pass(); | |
10039 } | |
10040 | |
10041 static void jtt_optimize_NCE_FlowSensitive03() { | |
10042 begin("jtt.optimize.NCE_FlowSensitive03"); | |
10043 String runString = null; | |
10044 try { | |
10045 // (null) == "null" | |
10046 runString = "(null)"; | |
10047 if (!"null".equals(jtt.optimize.NCE_FlowSensitive03.test(null))) { | |
10048 fail(runString); | |
10049 return; | |
10050 } | |
10051 // ("x") == "x" | |
10052 runString = "(\"x\")"; | |
10053 if (!"x".equals(jtt.optimize.NCE_FlowSensitive03.test("x"))) { | |
10054 fail(runString); | |
10055 return; | |
10056 } | |
10057 // ("yay") == "yay" | |
10058 runString = "(\"yay\")"; | |
10059 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive03.test("yay"))) { | |
10060 fail(runString); | |
10061 return; | |
10062 } | |
10063 } catch (Throwable t) { | |
10064 fail(runString, t); | |
10065 return; | |
10066 } | |
10067 pass(); | |
10068 } | |
10069 | |
10070 static void jtt_optimize_NCE_FlowSensitive04() { | |
10071 begin("jtt.optimize.NCE_FlowSensitive04"); | |
10072 String runString = null; | |
10073 try { | |
10074 // (null) == "null" | |
10075 runString = "(null)"; | |
10076 if (!"null".equals(jtt.optimize.NCE_FlowSensitive04.test(null))) { | |
10077 fail(runString); | |
10078 return; | |
10079 } | |
10080 // ("x") == "x" | |
10081 runString = "(\"x\")"; | |
10082 if (!"x".equals(jtt.optimize.NCE_FlowSensitive04.test("x"))) { | |
10083 fail(runString); | |
10084 return; | |
10085 } | |
10086 // ("yay") == "yay" | |
10087 runString = "(\"yay\")"; | |
10088 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive04.test("yay"))) { | |
10089 fail(runString); | |
10090 return; | |
10091 } | |
10092 } catch (Throwable t) { | |
10093 fail(runString, t); | |
10094 return; | |
10095 } | |
10096 pass(); | |
10097 } | |
10098 | |
10099 static void jtt_optimize_Narrow_byte01() { | |
10100 begin("jtt.optimize.Narrow_byte01"); | |
10101 String runString = null; | |
10102 try { | |
10103 // (0) == 0 | |
10104 runString = "(0)"; | |
10105 if ((byte) 0 != jtt.optimize.Narrow_byte01.test((byte) 0)) { | |
10106 fail(runString); | |
10107 return; | |
10108 } | |
10109 // (1) == 1 | |
10110 runString = "(1)"; | |
10111 if ((byte) 1 != jtt.optimize.Narrow_byte01.test((byte) 1)) { | |
10112 fail(runString); | |
10113 return; | |
10114 } | |
10115 // (-1) == -1 | |
10116 runString = "(-1)"; | |
10117 if ((byte) -1 != jtt.optimize.Narrow_byte01.test((byte) -1)) { | |
10118 fail(runString); | |
10119 return; | |
10120 } | |
10121 // (110) == 110 | |
10122 runString = "(110)"; | |
10123 if ((byte) 110 != jtt.optimize.Narrow_byte01.test((byte) 110)) { | |
10124 fail(runString); | |
10125 return; | |
10126 } | |
10127 } catch (Throwable t) { | |
10128 fail(runString, t); | |
10129 return; | |
10130 } | |
10131 pass(); | |
10132 } | |
10133 | |
10134 static void jtt_optimize_Narrow_byte02() { | |
10135 begin("jtt.optimize.Narrow_byte02"); | |
10136 String runString = null; | |
10137 try { | |
10138 // (0) == 0 | |
10139 runString = "(0)"; | |
10140 if ((byte) 0 != jtt.optimize.Narrow_byte02.test((byte) 0)) { | |
10141 fail(runString); | |
10142 return; | |
10143 } | |
10144 // (1) == 1 | |
10145 runString = "(1)"; | |
10146 if ((byte) 1 != jtt.optimize.Narrow_byte02.test((byte) 1)) { | |
10147 fail(runString); | |
10148 return; | |
10149 } | |
10150 // (-1) == -1 | |
10151 runString = "(-1)"; | |
10152 if ((byte) -1 != jtt.optimize.Narrow_byte02.test((byte) -1)) { | |
10153 fail(runString); | |
10154 return; | |
10155 } | |
10156 // (110) == 110 | |
10157 runString = "(110)"; | |
10158 if ((byte) 110 != jtt.optimize.Narrow_byte02.test((byte) 110)) { | |
10159 fail(runString); | |
10160 return; | |
10161 } | |
10162 } catch (Throwable t) { | |
10163 fail(runString, t); | |
10164 return; | |
10165 } | |
10166 pass(); | |
10167 } | |
10168 | |
10169 static void jtt_optimize_Narrow_byte03() { | |
10170 begin("jtt.optimize.Narrow_byte03"); | |
10171 String runString = null; | |
10172 try { | |
10173 // (0) == 0 | |
10174 runString = "(0)"; | |
10175 if ((byte) 0 != jtt.optimize.Narrow_byte03.test((byte) 0)) { | |
10176 fail(runString); | |
10177 return; | |
10178 } | |
10179 // (1) == 1 | |
10180 runString = "(1)"; | |
10181 if ((byte) 1 != jtt.optimize.Narrow_byte03.test((byte) 1)) { | |
10182 fail(runString); | |
10183 return; | |
10184 } | |
10185 // (-1) == -1 | |
10186 runString = "(-1)"; | |
10187 if ((byte) -1 != jtt.optimize.Narrow_byte03.test((byte) -1)) { | |
10188 fail(runString); | |
10189 return; | |
10190 } | |
10191 // (110) == 110 | |
10192 runString = "(110)"; | |
10193 if ((byte) 110 != jtt.optimize.Narrow_byte03.test((byte) 110)) { | |
10194 fail(runString); | |
10195 return; | |
10196 } | |
10197 } catch (Throwable t) { | |
10198 fail(runString, t); | |
10199 return; | |
10200 } | |
10201 pass(); | |
10202 } | |
10203 | |
10204 static void jtt_optimize_Narrow_char01() { | |
10205 begin("jtt.optimize.Narrow_char01"); | |
10206 String runString = null; | |
10207 try { | |
10208 // ('\0') == '\0' | |
10209 runString = "('\0')"; | |
10210 if ((char) 0 != jtt.optimize.Narrow_char01.test((char) 0)) { | |
10211 fail(runString); | |
10212 return; | |
10213 } | |
10214 // ('\1') == '\1' | |
10215 runString = "('\1')"; | |
10216 if ((char) 1 != jtt.optimize.Narrow_char01.test((char) 1)) { | |
10217 fail(runString); | |
10218 return; | |
10219 } | |
10220 // ('\377') == '\377' | |
10221 runString = "('\377')"; | |
10222 if ((char) 255 != jtt.optimize.Narrow_char01.test((char) 255)) { | |
10223 fail(runString); | |
10224 return; | |
10225 } | |
10226 // ('\176750') == '\176750' | |
10227 runString = "('\176750')"; | |
10228 if ((char) 65000 != jtt.optimize.Narrow_char01.test((char) 65000)) { | |
10229 fail(runString); | |
10230 return; | |
10231 } | |
10232 } catch (Throwable t) { | |
10233 fail(runString, t); | |
10234 return; | |
10235 } | |
10236 pass(); | |
10237 } | |
10238 | |
10239 static void jtt_optimize_Narrow_char02() { | |
10240 begin("jtt.optimize.Narrow_char02"); | |
10241 String runString = null; | |
10242 try { | |
10243 // ('\0') == '\0' | |
10244 runString = "('\0')"; | |
10245 if ((char) 0 != jtt.optimize.Narrow_char02.test((char) 0)) { | |
10246 fail(runString); | |
10247 return; | |
10248 } | |
10249 // ('\1') == '\1' | |
10250 runString = "('\1')"; | |
10251 if ((char) 1 != jtt.optimize.Narrow_char02.test((char) 1)) { | |
10252 fail(runString); | |
10253 return; | |
10254 } | |
10255 // ('\377') == '\377' | |
10256 runString = "('\377')"; | |
10257 if ((char) 255 != jtt.optimize.Narrow_char02.test((char) 255)) { | |
10258 fail(runString); | |
10259 return; | |
10260 } | |
10261 // ('\176750') == '\176750' | |
10262 runString = "('\176750')"; | |
10263 if ((char) 65000 != jtt.optimize.Narrow_char02.test((char) 65000)) { | |
10264 fail(runString); | |
10265 return; | |
10266 } | |
10267 } catch (Throwable t) { | |
10268 fail(runString, t); | |
10269 return; | |
10270 } | |
10271 pass(); | |
10272 } | |
10273 | |
10274 static void jtt_optimize_Narrow_char03() { | |
10275 begin("jtt.optimize.Narrow_char03"); | |
10276 String runString = null; | |
10277 try { | |
10278 // ('\0') == '\0' | |
10279 runString = "('\0')"; | |
10280 if ((char) 0 != jtt.optimize.Narrow_char03.test((char) 0)) { | |
10281 fail(runString); | |
10282 return; | |
10283 } | |
10284 // ('\1') == '\1' | |
10285 runString = "('\1')"; | |
10286 if ((char) 1 != jtt.optimize.Narrow_char03.test((char) 1)) { | |
10287 fail(runString); | |
10288 return; | |
10289 } | |
10290 // ('\377') == '\377' | |
10291 runString = "('\377')"; | |
10292 if ((char) 255 != jtt.optimize.Narrow_char03.test((char) 255)) { | |
10293 fail(runString); | |
10294 return; | |
10295 } | |
10296 // ('\176750') == '\176750' | |
10297 runString = "('\176750')"; | |
10298 if ((char) 65000 != jtt.optimize.Narrow_char03.test((char) 65000)) { | |
10299 fail(runString); | |
10300 return; | |
10301 } | |
10302 } catch (Throwable t) { | |
10303 fail(runString, t); | |
10304 return; | |
10305 } | |
10306 pass(); | |
10307 } | |
10308 | |
10309 static void jtt_optimize_Narrow_short01() { | |
10310 begin("jtt.optimize.Narrow_short01"); | |
10311 String runString = null; | |
10312 try { | |
10313 // (0) == 0 | |
10314 runString = "(0)"; | |
10315 if ((short) 0 != jtt.optimize.Narrow_short01.test((short) 0)) { | |
10316 fail(runString); | |
10317 return; | |
10318 } | |
10319 // (1) == 1 | |
10320 runString = "(1)"; | |
10321 if ((short) 1 != jtt.optimize.Narrow_short01.test((short) 1)) { | |
10322 fail(runString); | |
10323 return; | |
10324 } | |
10325 // (-1) == -1 | |
10326 runString = "(-1)"; | |
10327 if ((short) -1 != jtt.optimize.Narrow_short01.test((short) -1)) { | |
10328 fail(runString); | |
10329 return; | |
10330 } | |
10331 // (23110) == 23110 | |
10332 runString = "(23110)"; | |
10333 if ((short) 23110 != jtt.optimize.Narrow_short01 | |
10334 .test((short) 23110)) { | |
10335 fail(runString); | |
10336 return; | |
10337 } | |
10338 } catch (Throwable t) { | |
10339 fail(runString, t); | |
10340 return; | |
10341 } | |
10342 pass(); | |
10343 } | |
10344 | |
10345 static void jtt_optimize_Narrow_short02() { | |
10346 begin("jtt.optimize.Narrow_short02"); | |
10347 String runString = null; | |
10348 try { | |
10349 // (0) == 0 | |
10350 runString = "(0)"; | |
10351 if ((short) 0 != jtt.optimize.Narrow_short02.test((short) 0)) { | |
10352 fail(runString); | |
10353 return; | |
10354 } | |
10355 // (1) == 1 | |
10356 runString = "(1)"; | |
10357 if ((short) 1 != jtt.optimize.Narrow_short02.test((short) 1)) { | |
10358 fail(runString); | |
10359 return; | |
10360 } | |
10361 // (-1) == -1 | |
10362 runString = "(-1)"; | |
10363 if ((short) -1 != jtt.optimize.Narrow_short02.test((short) -1)) { | |
10364 fail(runString); | |
10365 return; | |
10366 } | |
10367 // (23110) == 23110 | |
10368 runString = "(23110)"; | |
10369 if ((short) 23110 != jtt.optimize.Narrow_short02 | |
10370 .test((short) 23110)) { | |
10371 fail(runString); | |
10372 return; | |
10373 } | |
10374 } catch (Throwable t) { | |
10375 fail(runString, t); | |
10376 return; | |
10377 } | |
10378 pass(); | |
10379 } | |
10380 | |
10381 static void jtt_optimize_Narrow_short03() { | |
10382 begin("jtt.optimize.Narrow_short03"); | |
10383 String runString = null; | |
10384 try { | |
10385 // (0) == 0 | |
10386 runString = "(0)"; | |
10387 if ((short) 0 != jtt.optimize.Narrow_short03.test((short) 0)) { | |
10388 fail(runString); | |
10389 return; | |
10390 } | |
10391 // (1) == 1 | |
10392 runString = "(1)"; | |
10393 if ((short) 1 != jtt.optimize.Narrow_short03.test((short) 1)) { | |
10394 fail(runString); | |
10395 return; | |
10396 } | |
10397 // (-1) == -1 | |
10398 runString = "(-1)"; | |
10399 if ((short) -1 != jtt.optimize.Narrow_short03.test((short) -1)) { | |
10400 fail(runString); | |
10401 return; | |
10402 } | |
10403 // (23110) == 23110 | |
10404 runString = "(23110)"; | |
10405 if ((short) 23110 != jtt.optimize.Narrow_short03 | |
10406 .test((short) 23110)) { | |
10407 fail(runString); | |
10408 return; | |
10409 } | |
10410 } catch (Throwable t) { | |
10411 fail(runString, t); | |
10412 return; | |
10413 } | |
10414 pass(); | |
10415 } | |
10416 | |
10417 static void jtt_optimize_Phi01() { | |
10418 begin("jtt.optimize.Phi01"); | |
10419 String runString = null; | |
10420 try { | |
10421 // (0) == 8 | |
10422 runString = "(0)"; | |
10423 if (8 != jtt.optimize.Phi01.test(0)) { | |
10424 fail(runString); | |
10425 return; | |
10426 } | |
10427 // (1) == 10 | |
10428 runString = "(1)"; | |
10429 if (10 != jtt.optimize.Phi01.test(1)) { | |
10430 fail(runString); | |
10431 return; | |
10432 } | |
10433 // (2) == 12 | |
10434 runString = "(2)"; | |
10435 if (12 != jtt.optimize.Phi01.test(2)) { | |
10436 fail(runString); | |
10437 return; | |
10438 } | |
10439 // (3) == 8 | |
10440 runString = "(3)"; | |
10441 if (8 != jtt.optimize.Phi01.test(3)) { | |
10442 fail(runString); | |
10443 return; | |
10444 } | |
10445 // (4) == 10 | |
10446 runString = "(4)"; | |
10447 if (10 != jtt.optimize.Phi01.test(4)) { | |
10448 fail(runString); | |
10449 return; | |
10450 } | |
10451 // (6) == 14 | |
10452 runString = "(6)"; | |
10453 if (14 != jtt.optimize.Phi01.test(6)) { | |
10454 fail(runString); | |
10455 return; | |
10456 } | |
10457 } catch (Throwable t) { | |
10458 fail(runString, t); | |
10459 return; | |
10460 } | |
10461 pass(); | |
10462 } | |
10463 | |
10464 static void jtt_optimize_Phi02() { | |
10465 begin("jtt.optimize.Phi02"); | |
10466 String runString = null; | |
10467 try { | |
10468 // (0) == 8 | |
10469 runString = "(0)"; | |
10470 if (8 != jtt.optimize.Phi02.test(0)) { | |
10471 fail(runString); | |
10472 return; | |
10473 } | |
10474 // (1) == 10 | |
10475 runString = "(1)"; | |
10476 if (10 != jtt.optimize.Phi02.test(1)) { | |
10477 fail(runString); | |
10478 return; | |
10479 } | |
10480 // (2) == 12 | |
10481 runString = "(2)"; | |
10482 if (12 != jtt.optimize.Phi02.test(2)) { | |
10483 fail(runString); | |
10484 return; | |
10485 } | |
10486 // (3) == 8 | |
10487 runString = "(3)"; | |
10488 if (8 != jtt.optimize.Phi02.test(3)) { | |
10489 fail(runString); | |
10490 return; | |
10491 } | |
10492 // (4) == 10 | |
10493 runString = "(4)"; | |
10494 if (10 != jtt.optimize.Phi02.test(4)) { | |
10495 fail(runString); | |
10496 return; | |
10497 } | |
10498 // (6) == 14 | |
10499 runString = "(6)"; | |
10500 if (14 != jtt.optimize.Phi02.test(6)) { | |
10501 fail(runString); | |
10502 return; | |
10503 } | |
10504 } catch (Throwable t) { | |
10505 fail(runString, t); | |
10506 return; | |
10507 } | |
10508 pass(); | |
10509 } | |
10510 | |
10511 static void jtt_optimize_Phi03() { | |
10512 begin("jtt.optimize.Phi03"); | |
10513 String runString = null; | |
10514 try { | |
10515 // (0) == 4 | |
10516 runString = "(0)"; | |
10517 if (4 != jtt.optimize.Phi03.test(0)) { | |
10518 fail(runString); | |
10519 return; | |
10520 } | |
10521 // (1) == 5 | |
10522 runString = "(1)"; | |
10523 if (5 != jtt.optimize.Phi03.test(1)) { | |
10524 fail(runString); | |
10525 return; | |
10526 } | |
10527 // (2) == 6 | |
10528 runString = "(2)"; | |
10529 if (6 != jtt.optimize.Phi03.test(2)) { | |
10530 fail(runString); | |
10531 return; | |
10532 } | |
10533 // (3) == 4 | |
10534 runString = "(3)"; | |
10535 if (4 != jtt.optimize.Phi03.test(3)) { | |
10536 fail(runString); | |
10537 return; | |
10538 } | |
10539 // (4) == 5 | |
10540 runString = "(4)"; | |
10541 if (5 != jtt.optimize.Phi03.test(4)) { | |
10542 fail(runString); | |
10543 return; | |
10544 } | |
10545 // (6) == 7 | |
10546 runString = "(6)"; | |
10547 if (7 != jtt.optimize.Phi03.test(6)) { | |
10548 fail(runString); | |
10549 return; | |
10550 } | |
10551 } catch (Throwable t) { | |
10552 fail(runString, t); | |
10553 return; | |
10554 } | |
10555 pass(); | |
10556 } | |
10557 | |
10558 static void jtt_optimize_Reduce_Convert01() { | |
10559 begin("jtt.optimize.Reduce_Convert01"); | |
10560 String runString = null; | |
10561 try { | |
10562 // (0) == 10 | |
10563 runString = "(0)"; | |
10564 if (10 != jtt.optimize.Reduce_Convert01.test(0)) { | |
10565 fail(runString); | |
10566 return; | |
10567 } | |
10568 // (1) == 11 | |
10569 runString = "(1)"; | |
10570 if (11 != jtt.optimize.Reduce_Convert01.test(1)) { | |
10571 fail(runString); | |
10572 return; | |
10573 } | |
10574 // (2) == 12 | |
10575 runString = "(2)"; | |
10576 if (12 != jtt.optimize.Reduce_Convert01.test(2)) { | |
10577 fail(runString); | |
10578 return; | |
10579 } | |
10580 } catch (Throwable t) { | |
10581 fail(runString, t); | |
10582 return; | |
10583 } | |
10584 pass(); | |
10585 } | |
10586 | |
10587 static void jtt_optimize_Reduce_Double01() { | |
10588 begin("jtt.optimize.Reduce_Double01"); | |
10589 String runString = null; | |
10590 try { | |
10591 // (0.0) == 10.0 | |
10592 runString = "(0.0)"; | |
10593 if (10.0 != jtt.optimize.Reduce_Double01.test(0.0)) { | |
10594 fail(runString); | |
10595 return; | |
10596 } | |
10597 // (1.0) == 11.0 | |
10598 runString = "(1.0)"; | |
10599 if (11.0 != jtt.optimize.Reduce_Double01.test(1.0)) { | |
10600 fail(runString); | |
10601 return; | |
10602 } | |
10603 // (2.0) == 12.0 | |
10604 runString = "(2.0)"; | |
10605 if (12.0 != jtt.optimize.Reduce_Double01.test(2.0)) { | |
10606 fail(runString); | |
10607 return; | |
10608 } | |
10609 // (3.0) == 13.0 | |
10610 runString = "(3.0)"; | |
10611 if (13.0 != jtt.optimize.Reduce_Double01.test(3.0)) { | |
10612 fail(runString); | |
10613 return; | |
10614 } | |
10615 } catch (Throwable t) { | |
10616 fail(runString, t); | |
10617 return; | |
10618 } | |
10619 pass(); | |
10620 } | |
10621 | |
10622 static void jtt_optimize_Reduce_Float01() { | |
10623 begin("jtt.optimize.Reduce_Float01"); | |
10624 String runString = null; | |
10625 try { | |
10626 // (0.0) == 10.0 | |
10627 runString = "(0.0)"; | |
10628 if (10.0f != jtt.optimize.Reduce_Float01.test(0.0f)) { | |
10629 fail(runString); | |
10630 return; | |
10631 } | |
10632 // (1.0) == 11.0 | |
10633 runString = "(1.0)"; | |
10634 if (11.0f != jtt.optimize.Reduce_Float01.test(1.0f)) { | |
10635 fail(runString); | |
10636 return; | |
10637 } | |
10638 // (2.0) == 12.0 | |
10639 runString = "(2.0)"; | |
10640 if (12.0f != jtt.optimize.Reduce_Float01.test(2.0f)) { | |
10641 fail(runString); | |
10642 return; | |
10643 } | |
10644 // (3.0) == 13.0 | |
10645 runString = "(3.0)"; | |
10646 if (13.0f != jtt.optimize.Reduce_Float01.test(3.0f)) { | |
10647 fail(runString); | |
10648 return; | |
10649 } | |
10650 } catch (Throwable t) { | |
10651 fail(runString, t); | |
10652 return; | |
10653 } | |
10654 pass(); | |
10655 } | |
10656 | |
10657 static void jtt_optimize_Reduce_Int01() { | |
10658 begin("jtt.optimize.Reduce_Int01"); | |
10659 String runString = null; | |
10660 try { | |
10661 // (0) == 10 | |
10662 runString = "(0)"; | |
10663 if (10 != jtt.optimize.Reduce_Int01.test(0)) { | |
10664 fail(runString); | |
10665 return; | |
10666 } | |
10667 // (1) == 11 | |
10668 runString = "(1)"; | |
10669 if (11 != jtt.optimize.Reduce_Int01.test(1)) { | |
10670 fail(runString); | |
10671 return; | |
10672 } | |
10673 // (2) == 12 | |
10674 runString = "(2)"; | |
10675 if (12 != jtt.optimize.Reduce_Int01.test(2)) { | |
10676 fail(runString); | |
10677 return; | |
10678 } | |
10679 // (3) == 13 | |
10680 runString = "(3)"; | |
10681 if (13 != jtt.optimize.Reduce_Int01.test(3)) { | |
10682 fail(runString); | |
10683 return; | |
10684 } | |
10685 // (4) == 14 | |
10686 runString = "(4)"; | |
10687 if (14 != jtt.optimize.Reduce_Int01.test(4)) { | |
10688 fail(runString); | |
10689 return; | |
10690 } | |
10691 // (5) == 15 | |
10692 runString = "(5)"; | |
10693 if (15 != jtt.optimize.Reduce_Int01.test(5)) { | |
10694 fail(runString); | |
10695 return; | |
10696 } | |
10697 // (6) == 16 | |
10698 runString = "(6)"; | |
10699 if (16 != jtt.optimize.Reduce_Int01.test(6)) { | |
10700 fail(runString); | |
10701 return; | |
10702 } | |
10703 // (7) == 17 | |
10704 runString = "(7)"; | |
10705 if (17 != jtt.optimize.Reduce_Int01.test(7)) { | |
10706 fail(runString); | |
10707 return; | |
10708 } | |
10709 } catch (Throwable t) { | |
10710 fail(runString, t); | |
10711 return; | |
10712 } | |
10713 pass(); | |
10714 } | |
10715 | |
10716 static void jtt_optimize_Reduce_Int02() { | |
10717 begin("jtt.optimize.Reduce_Int02"); | |
10718 String runString = null; | |
10719 try { | |
10720 // (0) == 10 | |
10721 runString = "(0)"; | |
10722 if (10 != jtt.optimize.Reduce_Int02.test(0)) { | |
10723 fail(runString); | |
10724 return; | |
10725 } | |
10726 // (1) == 11 | |
10727 runString = "(1)"; | |
10728 if (11 != jtt.optimize.Reduce_Int02.test(1)) { | |
10729 fail(runString); | |
10730 return; | |
10731 } | |
10732 // (2) == 12 | |
10733 runString = "(2)"; | |
10734 if (12 != jtt.optimize.Reduce_Int02.test(2)) { | |
10735 fail(runString); | |
10736 return; | |
10737 } | |
10738 // (3) == 13 | |
10739 runString = "(3)"; | |
10740 if (13 != jtt.optimize.Reduce_Int02.test(3)) { | |
10741 fail(runString); | |
10742 return; | |
10743 } | |
10744 // (4) == 14 | |
10745 runString = "(4)"; | |
10746 if (14 != jtt.optimize.Reduce_Int02.test(4)) { | |
10747 fail(runString); | |
10748 return; | |
10749 } | |
10750 // (5) == 15 | |
10751 runString = "(5)"; | |
10752 if (15 != jtt.optimize.Reduce_Int02.test(5)) { | |
10753 fail(runString); | |
10754 return; | |
10755 } | |
10756 // (6) == 16 | |
10757 runString = "(6)"; | |
10758 if (16 != jtt.optimize.Reduce_Int02.test(6)) { | |
10759 fail(runString); | |
10760 return; | |
10761 } | |
10762 // (7) == 17 | |
10763 runString = "(7)"; | |
10764 if (17 != jtt.optimize.Reduce_Int02.test(7)) { | |
10765 fail(runString); | |
10766 return; | |
10767 } | |
10768 } catch (Throwable t) { | |
10769 fail(runString, t); | |
10770 return; | |
10771 } | |
10772 pass(); | |
10773 } | |
10774 | |
10775 static void jtt_optimize_Reduce_Int03() { | |
10776 begin("jtt.optimize.Reduce_Int03"); | |
10777 String runString = null; | |
10778 try { | |
10779 // (0) == 10 | |
10780 runString = "(0)"; | |
10781 if (10 != jtt.optimize.Reduce_Int03.test(0)) { | |
10782 fail(runString); | |
10783 return; | |
10784 } | |
10785 // (1) == 0 | |
10786 runString = "(1)"; | |
10787 if (0 != jtt.optimize.Reduce_Int03.test(1)) { | |
10788 fail(runString); | |
10789 return; | |
10790 } | |
10791 // (2) == 25 | |
10792 runString = "(2)"; | |
10793 if (25 != jtt.optimize.Reduce_Int03.test(2)) { | |
10794 fail(runString); | |
10795 return; | |
10796 } | |
10797 // (3) == 1 | |
10798 runString = "(3)"; | |
10799 if (1 != jtt.optimize.Reduce_Int03.test(3)) { | |
10800 fail(runString); | |
10801 return; | |
10802 } | |
10803 // (4) == 0 | |
10804 runString = "(4)"; | |
10805 if (0 != jtt.optimize.Reduce_Int03.test(4)) { | |
10806 fail(runString); | |
10807 return; | |
10808 } | |
10809 // (5) == 15 | |
10810 runString = "(5)"; | |
10811 if (15 != jtt.optimize.Reduce_Int03.test(5)) { | |
10812 fail(runString); | |
10813 return; | |
10814 } | |
10815 // (6) == 16 | |
10816 runString = "(6)"; | |
10817 if (16 != jtt.optimize.Reduce_Int03.test(6)) { | |
10818 fail(runString); | |
10819 return; | |
10820 } | |
10821 // (7) == 0 | |
10822 runString = "(7)"; | |
10823 if (0 != jtt.optimize.Reduce_Int03.test(7)) { | |
10824 fail(runString); | |
10825 return; | |
10826 } | |
10827 } catch (Throwable t) { | |
10828 fail(runString, t); | |
10829 return; | |
10830 } | |
10831 pass(); | |
10832 } | |
10833 | |
10834 static void jtt_optimize_Reduce_Int04() { | |
10835 begin("jtt.optimize.Reduce_Int04"); | |
10836 String runString = null; | |
10837 try { | |
10838 // (0) == 40 | |
10839 runString = "(0)"; | |
10840 if (40 != jtt.optimize.Reduce_Int04.test(0)) { | |
10841 fail(runString); | |
10842 return; | |
10843 } | |
10844 // (1) == 655360 | |
10845 runString = "(1)"; | |
10846 if (655360 != jtt.optimize.Reduce_Int04.test(1)) { | |
10847 fail(runString); | |
10848 return; | |
10849 } | |
10850 } catch (Throwable t) { | |
10851 fail(runString, t); | |
10852 return; | |
10853 } | |
10854 pass(); | |
10855 } | |
10856 | |
10857 static void jtt_optimize_Reduce_IntShift01() { | |
10858 begin("jtt.optimize.Reduce_IntShift01"); | |
10859 String runString = null; | |
10860 try { | |
10861 // (0) == 10 | |
10862 runString = "(0)"; | |
10863 if (10 != jtt.optimize.Reduce_IntShift01.test(0)) { | |
10864 fail(runString); | |
10865 return; | |
10866 } | |
10867 // (1) == 11 | |
10868 runString = "(1)"; | |
10869 if (11 != jtt.optimize.Reduce_IntShift01.test(1)) { | |
10870 fail(runString); | |
10871 return; | |
10872 } | |
10873 // (2) == 12 | |
10874 runString = "(2)"; | |
10875 if (12 != jtt.optimize.Reduce_IntShift01.test(2)) { | |
10876 fail(runString); | |
10877 return; | |
10878 } | |
10879 // (3) == 13 | |
10880 runString = "(3)"; | |
10881 if (13 != jtt.optimize.Reduce_IntShift01.test(3)) { | |
10882 fail(runString); | |
10883 return; | |
10884 } | |
10885 // (4) == 14 | |
10886 runString = "(4)"; | |
10887 if (14 != jtt.optimize.Reduce_IntShift01.test(4)) { | |
10888 fail(runString); | |
10889 return; | |
10890 } | |
10891 // (5) == 15 | |
10892 runString = "(5)"; | |
10893 if (15 != jtt.optimize.Reduce_IntShift01.test(5)) { | |
10894 fail(runString); | |
10895 return; | |
10896 } | |
10897 } catch (Throwable t) { | |
10898 fail(runString, t); | |
10899 return; | |
10900 } | |
10901 pass(); | |
10902 } | |
10903 | |
10904 static void jtt_optimize_Reduce_IntShift02() { | |
10905 begin("jtt.optimize.Reduce_IntShift02"); | |
10906 String runString = null; | |
10907 try { | |
10908 // (0) == 80 | |
10909 runString = "(0)"; | |
10910 if (80 != jtt.optimize.Reduce_IntShift02.test(0)) { | |
10911 fail(runString); | |
10912 return; | |
10913 } | |
10914 // (1) == 11 | |
10915 runString = "(1)"; | |
10916 if (11 != jtt.optimize.Reduce_IntShift02.test(1)) { | |
10917 fail(runString); | |
10918 return; | |
10919 } | |
10920 // (2) == 12 | |
10921 runString = "(2)"; | |
10922 if (12 != jtt.optimize.Reduce_IntShift02.test(2)) { | |
10923 fail(runString); | |
10924 return; | |
10925 } | |
10926 // (3) == 13 | |
10927 runString = "(3)"; | |
10928 if (13 != jtt.optimize.Reduce_IntShift02.test(3)) { | |
10929 fail(runString); | |
10930 return; | |
10931 } | |
10932 // (4) == 64 | |
10933 runString = "(4)"; | |
10934 if (64 != jtt.optimize.Reduce_IntShift02.test(4)) { | |
10935 fail(runString); | |
10936 return; | |
10937 } | |
10938 } catch (Throwable t) { | |
10939 fail(runString, t); | |
10940 return; | |
10941 } | |
10942 pass(); | |
10943 } | |
10944 | |
10945 static void jtt_optimize_Reduce_Long01() { | |
10946 begin("jtt.optimize.Reduce_Long01"); | |
10947 String runString = null; | |
10948 try { | |
10949 // (0) == 10 | |
10950 runString = "(0)"; | |
10951 if (10L != jtt.optimize.Reduce_Long01.test(0)) { | |
10952 fail(runString); | |
10953 return; | |
10954 } | |
10955 // (1) == 11 | |
10956 runString = "(1)"; | |
10957 if (11L != jtt.optimize.Reduce_Long01.test(1)) { | |
10958 fail(runString); | |
10959 return; | |
10960 } | |
10961 // (2) == 12 | |
10962 runString = "(2)"; | |
10963 if (12L != jtt.optimize.Reduce_Long01.test(2)) { | |
10964 fail(runString); | |
10965 return; | |
10966 } | |
10967 // (3) == 13 | |
10968 runString = "(3)"; | |
10969 if (13L != jtt.optimize.Reduce_Long01.test(3)) { | |
10970 fail(runString); | |
10971 return; | |
10972 } | |
10973 // (4) == 14 | |
10974 runString = "(4)"; | |
10975 if (14L != jtt.optimize.Reduce_Long01.test(4)) { | |
10976 fail(runString); | |
10977 return; | |
10978 } | |
10979 // (5) == 15 | |
10980 runString = "(5)"; | |
10981 if (15L != jtt.optimize.Reduce_Long01.test(5)) { | |
10982 fail(runString); | |
10983 return; | |
10984 } | |
10985 // (6) == 16 | |
10986 runString = "(6)"; | |
10987 if (16L != jtt.optimize.Reduce_Long01.test(6)) { | |
10988 fail(runString); | |
10989 return; | |
10990 } | |
10991 // (7) == 17 | |
10992 runString = "(7)"; | |
10993 if (17L != jtt.optimize.Reduce_Long01.test(7)) { | |
10994 fail(runString); | |
10995 return; | |
10996 } | |
10997 } catch (Throwable t) { | |
10998 fail(runString, t); | |
10999 return; | |
11000 } | |
11001 pass(); | |
11002 } | |
11003 | |
11004 static void jtt_optimize_Reduce_Long02() { | |
11005 begin("jtt.optimize.Reduce_Long02"); | |
11006 String runString = null; | |
11007 try { | |
11008 // (0) == 10 | |
11009 runString = "(0)"; | |
11010 if (10L != jtt.optimize.Reduce_Long02.test(0)) { | |
11011 fail(runString); | |
11012 return; | |
11013 } | |
11014 // (1) == 11 | |
11015 runString = "(1)"; | |
11016 if (11L != jtt.optimize.Reduce_Long02.test(1)) { | |
11017 fail(runString); | |
11018 return; | |
11019 } | |
11020 // (2) == 12 | |
11021 runString = "(2)"; | |
11022 if (12L != jtt.optimize.Reduce_Long02.test(2)) { | |
11023 fail(runString); | |
11024 return; | |
11025 } | |
11026 // (3) == 13 | |
11027 runString = "(3)"; | |
11028 if (13L != jtt.optimize.Reduce_Long02.test(3)) { | |
11029 fail(runString); | |
11030 return; | |
11031 } | |
11032 // (4) == 14 | |
11033 runString = "(4)"; | |
11034 if (14L != jtt.optimize.Reduce_Long02.test(4)) { | |
11035 fail(runString); | |
11036 return; | |
11037 } | |
11038 // (5) == 15 | |
11039 runString = "(5)"; | |
11040 if (15L != jtt.optimize.Reduce_Long02.test(5)) { | |
11041 fail(runString); | |
11042 return; | |
11043 } | |
11044 // (6) == 16 | |
11045 runString = "(6)"; | |
11046 if (16L != jtt.optimize.Reduce_Long02.test(6)) { | |
11047 fail(runString); | |
11048 return; | |
11049 } | |
11050 // (7) == 17 | |
11051 runString = "(7)"; | |
11052 if (17L != jtt.optimize.Reduce_Long02.test(7)) { | |
11053 fail(runString); | |
11054 return; | |
11055 } | |
11056 } catch (Throwable t) { | |
11057 fail(runString, t); | |
11058 return; | |
11059 } | |
11060 pass(); | |
11061 } | |
11062 | |
11063 static void jtt_optimize_Reduce_Long03() { | |
11064 begin("jtt.optimize.Reduce_Long03"); | |
11065 String runString = null; | |
11066 try { | |
11067 // (0) == 10 | |
11068 runString = "(0)"; | |
11069 if (10L != jtt.optimize.Reduce_Long03.test(0)) { | |
11070 fail(runString); | |
11071 return; | |
11072 } | |
11073 // (1) == 0 | |
11074 runString = "(1)"; | |
11075 if (0L != jtt.optimize.Reduce_Long03.test(1)) { | |
11076 fail(runString); | |
11077 return; | |
11078 } | |
11079 // (2) == 25 | |
11080 runString = "(2)"; | |
11081 if (25L != jtt.optimize.Reduce_Long03.test(2)) { | |
11082 fail(runString); | |
11083 return; | |
11084 } | |
11085 // (3) == 1 | |
11086 runString = "(3)"; | |
11087 if (1L != jtt.optimize.Reduce_Long03.test(3)) { | |
11088 fail(runString); | |
11089 return; | |
11090 } | |
11091 // (4) == 0 | |
11092 runString = "(4)"; | |
11093 if (0L != jtt.optimize.Reduce_Long03.test(4)) { | |
11094 fail(runString); | |
11095 return; | |
11096 } | |
11097 // (5) == 15 | |
11098 runString = "(5)"; | |
11099 if (15L != jtt.optimize.Reduce_Long03.test(5)) { | |
11100 fail(runString); | |
11101 return; | |
11102 } | |
11103 // (6) == 16 | |
11104 runString = "(6)"; | |
11105 if (16L != jtt.optimize.Reduce_Long03.test(6)) { | |
11106 fail(runString); | |
11107 return; | |
11108 } | |
11109 // (7) == 0 | |
11110 runString = "(7)"; | |
11111 if (0L != jtt.optimize.Reduce_Long03.test(7)) { | |
11112 fail(runString); | |
11113 return; | |
11114 } | |
11115 } catch (Throwable t) { | |
11116 fail(runString, t); | |
11117 return; | |
11118 } | |
11119 pass(); | |
11120 } | |
11121 | |
11122 static void jtt_optimize_Reduce_Long04() { | |
11123 begin("jtt.optimize.Reduce_Long04"); | |
11124 String runString = null; | |
11125 try { | |
11126 // (0) == 40 | |
11127 runString = "(0)"; | |
11128 if (40L != jtt.optimize.Reduce_Long04.test(0)) { | |
11129 fail(runString); | |
11130 return; | |
11131 } | |
11132 // (1) == 85899345920 | |
11133 runString = "(1)"; | |
11134 if (85899345920L != jtt.optimize.Reduce_Long04.test(1)) { | |
11135 fail(runString); | |
11136 return; | |
11137 } | |
11138 } catch (Throwable t) { | |
11139 fail(runString, t); | |
11140 return; | |
11141 } | |
11142 pass(); | |
11143 } | |
11144 | |
11145 static void jtt_optimize_Reduce_LongShift01() { | |
11146 begin("jtt.optimize.Reduce_LongShift01"); | |
11147 String runString = null; | |
11148 try { | |
11149 // (0) == 10 | |
11150 runString = "(0)"; | |
11151 if (10L != jtt.optimize.Reduce_LongShift01.test(0)) { | |
11152 fail(runString); | |
11153 return; | |
11154 } | |
11155 // (1) == 11 | |
11156 runString = "(1)"; | |
11157 if (11L != jtt.optimize.Reduce_LongShift01.test(1)) { | |
11158 fail(runString); | |
11159 return; | |
11160 } | |
11161 // (2) == 12 | |
11162 runString = "(2)"; | |
11163 if (12L != jtt.optimize.Reduce_LongShift01.test(2)) { | |
11164 fail(runString); | |
11165 return; | |
11166 } | |
11167 // (3) == 13 | |
11168 runString = "(3)"; | |
11169 if (13L != jtt.optimize.Reduce_LongShift01.test(3)) { | |
11170 fail(runString); | |
11171 return; | |
11172 } | |
11173 // (4) == 14 | |
11174 runString = "(4)"; | |
11175 if (14L != jtt.optimize.Reduce_LongShift01.test(4)) { | |
11176 fail(runString); | |
11177 return; | |
11178 } | |
11179 // (5) == 15 | |
11180 runString = "(5)"; | |
11181 if (15L != jtt.optimize.Reduce_LongShift01.test(5)) { | |
11182 fail(runString); | |
11183 return; | |
11184 } | |
11185 } catch (Throwable t) { | |
11186 fail(runString, t); | |
11187 return; | |
11188 } | |
11189 pass(); | |
11190 } | |
11191 | |
11192 static void jtt_optimize_Reduce_LongShift02() { | |
11193 begin("jtt.optimize.Reduce_LongShift02"); | |
11194 String runString = null; | |
11195 try { | |
11196 // (0) == 80 | |
11197 runString = "(0)"; | |
11198 if (80L != jtt.optimize.Reduce_LongShift02.test(0)) { | |
11199 fail(runString); | |
11200 return; | |
11201 } | |
11202 // (1) == 11 | |
11203 runString = "(1)"; | |
11204 if (11L != jtt.optimize.Reduce_LongShift02.test(1)) { | |
11205 fail(runString); | |
11206 return; | |
11207 } | |
11208 // (2) == 12 | |
11209 runString = "(2)"; | |
11210 if (12L != jtt.optimize.Reduce_LongShift02.test(2)) { | |
11211 fail(runString); | |
11212 return; | |
11213 } | |
11214 // (3) == 13 | |
11215 runString = "(3)"; | |
11216 if (13L != jtt.optimize.Reduce_LongShift02.test(3)) { | |
11217 fail(runString); | |
11218 return; | |
11219 } | |
11220 // (4) == 64 | |
11221 runString = "(4)"; | |
11222 if (64L != jtt.optimize.Reduce_LongShift02.test(4)) { | |
11223 fail(runString); | |
11224 return; | |
11225 } | |
11226 } catch (Throwable t) { | |
11227 fail(runString, t); | |
11228 return; | |
11229 } | |
11230 pass(); | |
11231 } | |
11232 | |
11233 static void jtt_optimize_Switch01() { | |
11234 begin("jtt.optimize.Switch01"); | |
11235 String runString = null; | |
11236 try { | |
11237 // (0) == 1 | |
11238 runString = "(0)"; | |
11239 if (1 != jtt.optimize.Switch01.test(0)) { | |
11240 fail(runString); | |
11241 return; | |
11242 } | |
11243 } catch (Throwable t) { | |
11244 fail(runString, t); | |
11245 return; | |
11246 } | |
11247 pass(); | |
11248 } | |
11249 | |
11250 static void jtt_optimize_Switch02() { | |
11251 begin("jtt.optimize.Switch02"); | |
11252 String runString = null; | |
11253 try { | |
11254 // (0) == 1 | |
11255 runString = "(0)"; | |
11256 if (1 != jtt.optimize.Switch02.test(0)) { | |
11257 fail(runString); | |
11258 return; | |
11259 } | |
11260 // (1) == 2 | |
11261 runString = "(1)"; | |
11262 if (2 != jtt.optimize.Switch02.test(1)) { | |
11263 fail(runString); | |
11264 return; | |
11265 } | |
11266 } catch (Throwable t) { | |
11267 fail(runString, t); | |
11268 return; | |
11269 } | |
11270 pass(); | |
11271 } | |
11272 | |
11273 static void jtt_optimize_TypeCastElem() { | |
11274 begin("jtt.optimize.TypeCastElem"); | |
11275 String runString = null; | |
11276 try { | |
11277 // (10,13,25) == 27183 | |
11278 runString = "(10,13,25)"; | |
11279 if (27183 != jtt.optimize.TypeCastElem.test(10, 13, 25)) { | |
11280 fail(runString); | |
11281 return; | |
11282 } | |
11283 } catch (Throwable t) { | |
11284 fail(runString, t); | |
11285 return; | |
11286 } | |
11287 pass(); | |
11288 } | |
11289 | |
11290 static void jtt_optimize_VN_Cast01() { | |
11291 begin("jtt.optimize.VN_Cast01"); | |
11292 String runString = null; | |
11293 try { | |
11294 // (0) == 18 | |
11295 runString = "(0)"; | |
11296 if (18 != jtt.optimize.VN_Cast01.test(0)) { | |
11297 fail(runString); | |
11298 return; | |
11299 } | |
11300 // (1) == 18 | |
11301 runString = "(1)"; | |
11302 if (18 != jtt.optimize.VN_Cast01.test(1)) { | |
11303 fail(runString); | |
11304 return; | |
11305 } | |
11306 // (2) == !java.lang.NullPointerException | |
11307 try { | |
11308 runString = "(2)"; | |
11309 jtt.optimize.VN_Cast01.test(2); | |
11310 fail(runString); | |
11311 return; | |
11312 } catch (Throwable e) { | |
11313 if (e.getClass() != java.lang.NullPointerException.class) { | |
11314 fail(runString, e); | |
11315 return; | |
11316 } | |
11317 } | |
11318 } catch (Throwable t) { | |
11319 fail(runString, t); | |
11320 return; | |
11321 } | |
11322 pass(); | |
11323 } | |
11324 | |
11325 static void jtt_optimize_VN_Cast02() { | |
11326 begin("jtt.optimize.VN_Cast02"); | |
11327 String runString = null; | |
11328 try { | |
11329 // (0) == 18 | |
11330 runString = "(0)"; | |
11331 if (18 != jtt.optimize.VN_Cast02.test(0)) { | |
11332 fail(runString); | |
11333 return; | |
11334 } | |
11335 // (1) == 18 | |
11336 runString = "(1)"; | |
11337 if (18 != jtt.optimize.VN_Cast02.test(1)) { | |
11338 fail(runString); | |
11339 return; | |
11340 } | |
11341 // (2) == !java.lang.NullPointerException | |
11342 try { | |
11343 runString = "(2)"; | |
11344 jtt.optimize.VN_Cast02.test(2); | |
11345 fail(runString); | |
11346 return; | |
11347 } catch (Throwable e) { | |
11348 if (e.getClass() != java.lang.NullPointerException.class) { | |
11349 fail(runString, e); | |
11350 return; | |
11351 } | |
11352 } | |
11353 } catch (Throwable t) { | |
11354 fail(runString, t); | |
11355 return; | |
11356 } | |
11357 pass(); | |
11358 } | |
11359 | |
11360 static void jtt_optimize_VN_Convert01() { | |
11361 begin("jtt.optimize.VN_Convert01"); | |
11362 String runString = null; | |
11363 try { | |
11364 // (0) == 20 | |
11365 runString = "(0)"; | |
11366 if (20 != jtt.optimize.VN_Convert01.test(0)) { | |
11367 fail(runString); | |
11368 return; | |
11369 } | |
11370 // (1) == 22 | |
11371 runString = "(1)"; | |
11372 if (22 != jtt.optimize.VN_Convert01.test(1)) { | |
11373 fail(runString); | |
11374 return; | |
11375 } | |
11376 // (2) == 24 | |
11377 runString = "(2)"; | |
11378 if (24 != jtt.optimize.VN_Convert01.test(2)) { | |
11379 fail(runString); | |
11380 return; | |
11381 } | |
11382 } catch (Throwable t) { | |
11383 fail(runString, t); | |
11384 return; | |
11385 } | |
11386 pass(); | |
11387 } | |
11388 | |
11389 static void jtt_optimize_VN_Convert02() { | |
11390 begin("jtt.optimize.VN_Convert02"); | |
11391 String runString = null; | |
11392 try { | |
11393 // (0) == 20 | |
11394 runString = "(0)"; | |
11395 if (20 != jtt.optimize.VN_Convert02.test(0)) { | |
11396 fail(runString); | |
11397 return; | |
11398 } | |
11399 // (1) == 22 | |
11400 runString = "(1)"; | |
11401 if (22 != jtt.optimize.VN_Convert02.test(1)) { | |
11402 fail(runString); | |
11403 return; | |
11404 } | |
11405 // (2) == 24 | |
11406 runString = "(2)"; | |
11407 if (24 != jtt.optimize.VN_Convert02.test(2)) { | |
11408 fail(runString); | |
11409 return; | |
11410 } | |
11411 } catch (Throwable t) { | |
11412 fail(runString, t); | |
11413 return; | |
11414 } | |
11415 pass(); | |
11416 } | |
11417 | |
11418 static void jtt_optimize_VN_Double01() { | |
11419 begin("jtt.optimize.VN_Double01"); | |
11420 String runString = null; | |
11421 try { | |
11422 // (0.0) == 22.0 | |
11423 runString = "(0.0)"; | |
11424 if (22.0 != jtt.optimize.VN_Double01.test(0.0)) { | |
11425 fail(runString); | |
11426 return; | |
11427 } | |
11428 // (1.0) == 0.0 | |
11429 runString = "(1.0)"; | |
11430 if (0.0 != jtt.optimize.VN_Double01.test(1.0)) { | |
11431 fail(runString); | |
11432 return; | |
11433 } | |
11434 // (2.0) == 144.0 | |
11435 runString = "(2.0)"; | |
11436 if (144.0 != jtt.optimize.VN_Double01.test(2.0)) { | |
11437 fail(runString); | |
11438 return; | |
11439 } | |
11440 // (3.0) == 1.0 | |
11441 runString = "(3.0)"; | |
11442 if (1.0 != jtt.optimize.VN_Double01.test(3.0)) { | |
11443 fail(runString); | |
11444 return; | |
11445 } | |
11446 } catch (Throwable t) { | |
11447 fail(runString, t); | |
11448 return; | |
11449 } | |
11450 pass(); | |
11451 } | |
11452 | |
11453 static void jtt_optimize_VN_Double02() { | |
11454 begin("jtt.optimize.VN_Double02"); | |
11455 String runString = null; | |
11456 try { | |
11457 // (0.0) == 22.0 | |
11458 runString = "(0.0)"; | |
11459 if (22.0 != jtt.optimize.VN_Double02.test(0.0)) { | |
11460 fail(runString); | |
11461 return; | |
11462 } | |
11463 // (1.0) == 0.0 | |
11464 runString = "(1.0)"; | |
11465 if (0.0 != jtt.optimize.VN_Double02.test(1.0)) { | |
11466 fail(runString); | |
11467 return; | |
11468 } | |
11469 // (2.0) == 144.0 | |
11470 runString = "(2.0)"; | |
11471 if (144.0 != jtt.optimize.VN_Double02.test(2.0)) { | |
11472 fail(runString); | |
11473 return; | |
11474 } | |
11475 // (3.0) == 1.0 | |
11476 runString = "(3.0)"; | |
11477 if (1.0 != jtt.optimize.VN_Double02.test(3.0)) { | |
11478 fail(runString); | |
11479 return; | |
11480 } | |
11481 } catch (Throwable t) { | |
11482 fail(runString, t); | |
11483 return; | |
11484 } | |
11485 pass(); | |
11486 } | |
11487 | |
11488 static void jtt_optimize_VN_Field01() { | |
11489 begin("jtt.optimize.VN_Field01"); | |
11490 String runString = null; | |
11491 try { | |
11492 // (0) == 18 | |
11493 runString = "(0)"; | |
11494 if (18 != jtt.optimize.VN_Field01.test(0)) { | |
11495 fail(runString); | |
11496 return; | |
11497 } | |
11498 // (1) == 18 | |
11499 runString = "(1)"; | |
11500 if (18 != jtt.optimize.VN_Field01.test(1)) { | |
11501 fail(runString); | |
11502 return; | |
11503 } | |
11504 // (2) == !java.lang.NullPointerException | |
11505 try { | |
11506 runString = "(2)"; | |
11507 jtt.optimize.VN_Field01.test(2); | |
11508 fail(runString); | |
11509 return; | |
11510 } catch (Throwable e) { | |
11511 if (e.getClass() != java.lang.NullPointerException.class) { | |
11512 fail(runString, e); | |
11513 return; | |
11514 } | |
11515 } | |
11516 } catch (Throwable t) { | |
11517 fail(runString, t); | |
11518 return; | |
11519 } | |
11520 pass(); | |
11521 } | |
11522 | |
11523 static void jtt_optimize_VN_Field02() { | |
11524 begin("jtt.optimize.VN_Field02"); | |
11525 String runString = null; | |
11526 try { | |
11527 // (0) == 18 | |
11528 runString = "(0)"; | |
11529 if (18 != jtt.optimize.VN_Field02.test(0)) { | |
11530 fail(runString); | |
11531 return; | |
11532 } | |
11533 // (1) == 18 | |
11534 runString = "(1)"; | |
11535 if (18 != jtt.optimize.VN_Field02.test(1)) { | |
11536 fail(runString); | |
11537 return; | |
11538 } | |
11539 // (2) == !java.lang.NullPointerException | |
11540 try { | |
11541 runString = "(2)"; | |
11542 jtt.optimize.VN_Field02.test(2); | |
11543 fail(runString); | |
11544 return; | |
11545 } catch (Throwable e) { | |
11546 if (e.getClass() != java.lang.NullPointerException.class) { | |
11547 fail(runString, e); | |
11548 return; | |
11549 } | |
11550 } | |
11551 } catch (Throwable t) { | |
11552 fail(runString, t); | |
11553 return; | |
11554 } | |
11555 pass(); | |
11556 } | |
11557 | |
11558 static void jtt_optimize_VN_Float01() { | |
11559 begin("jtt.optimize.VN_Float01"); | |
11560 String runString = null; | |
11561 try { | |
11562 // (0.0) == 22.0 | |
11563 runString = "(0.0)"; | |
11564 if (22.0f != jtt.optimize.VN_Float01.test(0.0f)) { | |
11565 fail(runString); | |
11566 return; | |
11567 } | |
11568 // (1.0) == 0.0 | |
11569 runString = "(1.0)"; | |
11570 if (0.0f != jtt.optimize.VN_Float01.test(1.0f)) { | |
11571 fail(runString); | |
11572 return; | |
11573 } | |
11574 // (2.0) == 144.0 | |
11575 runString = "(2.0)"; | |
11576 if (144.0f != jtt.optimize.VN_Float01.test(2.0f)) { | |
11577 fail(runString); | |
11578 return; | |
11579 } | |
11580 // (3.0) == 1.0 | |
11581 runString = "(3.0)"; | |
11582 if (1.0f != jtt.optimize.VN_Float01.test(3.0f)) { | |
11583 fail(runString); | |
11584 return; | |
11585 } | |
11586 } catch (Throwable t) { | |
11587 fail(runString, t); | |
11588 return; | |
11589 } | |
11590 pass(); | |
11591 } | |
11592 | |
11593 static void jtt_optimize_VN_Float02() { | |
11594 begin("jtt.optimize.VN_Float02"); | |
11595 String runString = null; | |
11596 try { | |
11597 // (0.0) == 22.0 | |
11598 runString = "(0.0)"; | |
11599 if (22.0f != jtt.optimize.VN_Float02.test(0.0f)) { | |
11600 fail(runString); | |
11601 return; | |
11602 } | |
11603 // (1.0) == 0.0 | |
11604 runString = "(1.0)"; | |
11605 if (0.0f != jtt.optimize.VN_Float02.test(1.0f)) { | |
11606 fail(runString); | |
11607 return; | |
11608 } | |
11609 // (2.0) == 144.0 | |
11610 runString = "(2.0)"; | |
11611 if (144.0f != jtt.optimize.VN_Float02.test(2.0f)) { | |
11612 fail(runString); | |
11613 return; | |
11614 } | |
11615 // (3.0) == 1.0 | |
11616 runString = "(3.0)"; | |
11617 if (1.0f != jtt.optimize.VN_Float02.test(3.0f)) { | |
11618 fail(runString); | |
11619 return; | |
11620 } | |
11621 } catch (Throwable t) { | |
11622 fail(runString, t); | |
11623 return; | |
11624 } | |
11625 pass(); | |
11626 } | |
11627 | |
11628 static void jtt_optimize_VN_InstanceOf01() { | |
11629 begin("jtt.optimize.VN_InstanceOf01"); | |
11630 String runString = null; | |
11631 try { | |
11632 // (0) == true | |
11633 runString = "(0)"; | |
11634 if (true != jtt.optimize.VN_InstanceOf01.test(0)) { | |
11635 fail(runString); | |
11636 return; | |
11637 } | |
11638 // (1) == true | |
11639 runString = "(1)"; | |
11640 if (true != jtt.optimize.VN_InstanceOf01.test(1)) { | |
11641 fail(runString); | |
11642 return; | |
11643 } | |
11644 // (2) == false | |
11645 runString = "(2)"; | |
11646 if (false != jtt.optimize.VN_InstanceOf01.test(2)) { | |
11647 fail(runString); | |
11648 return; | |
11649 } | |
11650 } catch (Throwable t) { | |
11651 fail(runString, t); | |
11652 return; | |
11653 } | |
11654 pass(); | |
11655 } | |
11656 | |
11657 static void jtt_optimize_VN_InstanceOf02() { | |
11658 begin("jtt.optimize.VN_InstanceOf02"); | |
11659 String runString = null; | |
11660 try { | |
11661 // (0) == true | |
11662 runString = "(0)"; | |
11663 if (true != jtt.optimize.VN_InstanceOf02.test(0)) { | |
11664 fail(runString); | |
11665 return; | |
11666 } | |
11667 // (1) == true | |
11668 runString = "(1)"; | |
11669 if (true != jtt.optimize.VN_InstanceOf02.test(1)) { | |
11670 fail(runString); | |
11671 return; | |
11672 } | |
11673 // (2) == false | |
11674 runString = "(2)"; | |
11675 if (false != jtt.optimize.VN_InstanceOf02.test(2)) { | |
11676 fail(runString); | |
11677 return; | |
11678 } | |
11679 } catch (Throwable t) { | |
11680 fail(runString, t); | |
11681 return; | |
11682 } | |
11683 pass(); | |
11684 } | |
11685 | |
11686 static void jtt_optimize_VN_InstanceOf03() { | |
11687 begin("jtt.optimize.VN_InstanceOf03"); | |
11688 String runString = null; | |
11689 try { | |
11690 // (0) == true | |
11691 runString = "(0)"; | |
11692 if (true != jtt.optimize.VN_InstanceOf03.test(0)) { | |
11693 fail(runString); | |
11694 return; | |
11695 } | |
11696 // (1) == true | |
11697 runString = "(1)"; | |
11698 if (true != jtt.optimize.VN_InstanceOf03.test(1)) { | |
11699 fail(runString); | |
11700 return; | |
11701 } | |
11702 // (2) == true | |
11703 runString = "(2)"; | |
11704 if (true != jtt.optimize.VN_InstanceOf03.test(2)) { | |
11705 fail(runString); | |
11706 return; | |
11707 } | |
11708 } catch (Throwable t) { | |
11709 fail(runString, t); | |
11710 return; | |
11711 } | |
11712 pass(); | |
11713 } | |
11714 | |
11715 static void jtt_optimize_VN_Int01() { | |
11716 begin("jtt.optimize.VN_Int01"); | |
11717 String runString = null; | |
11718 try { | |
11719 // (0) == 6 | |
11720 runString = "(0)"; | |
11721 if (6 != jtt.optimize.VN_Int01.test(0)) { | |
11722 fail(runString); | |
11723 return; | |
11724 } | |
11725 // (1) == 0 | |
11726 runString = "(1)"; | |
11727 if (0 != jtt.optimize.VN_Int01.test(1)) { | |
11728 fail(runString); | |
11729 return; | |
11730 } | |
11731 // (2) == 36 | |
11732 runString = "(2)"; | |
11733 if (36 != jtt.optimize.VN_Int01.test(2)) { | |
11734 fail(runString); | |
11735 return; | |
11736 } | |
11737 // (3) == 1 | |
11738 runString = "(3)"; | |
11739 if (1 != jtt.optimize.VN_Int01.test(3)) { | |
11740 fail(runString); | |
11741 return; | |
11742 } | |
11743 // (4) == 0 | |
11744 runString = "(4)"; | |
11745 if (0 != jtt.optimize.VN_Int01.test(4)) { | |
11746 fail(runString); | |
11747 return; | |
11748 } | |
11749 // (5) == 5 | |
11750 runString = "(5)"; | |
11751 if (5 != jtt.optimize.VN_Int01.test(5)) { | |
11752 fail(runString); | |
11753 return; | |
11754 } | |
11755 // (6) == 7 | |
11756 runString = "(6)"; | |
11757 if (7 != jtt.optimize.VN_Int01.test(6)) { | |
11758 fail(runString); | |
11759 return; | |
11760 } | |
11761 // (7) == 0 | |
11762 runString = "(7)"; | |
11763 if (0 != jtt.optimize.VN_Int01.test(7)) { | |
11764 fail(runString); | |
11765 return; | |
11766 } | |
11767 } catch (Throwable t) { | |
11768 fail(runString, t); | |
11769 return; | |
11770 } | |
11771 pass(); | |
11772 } | |
11773 | |
11774 static void jtt_optimize_VN_Int02() { | |
11775 begin("jtt.optimize.VN_Int02"); | |
11776 String runString = null; | |
11777 try { | |
11778 // (0) == 10 | |
11779 runString = "(0)"; | |
11780 if (10 != jtt.optimize.VN_Int02.test(0)) { | |
11781 fail(runString); | |
11782 return; | |
11783 } | |
11784 // (1) == 10 | |
11785 runString = "(1)"; | |
11786 if (10 != jtt.optimize.VN_Int02.test(1)) { | |
11787 fail(runString); | |
11788 return; | |
11789 } | |
11790 // (2) == 48 | |
11791 runString = "(2)"; | |
11792 if (48 != jtt.optimize.VN_Int02.test(2)) { | |
11793 fail(runString); | |
11794 return; | |
11795 } | |
11796 } catch (Throwable t) { | |
11797 fail(runString, t); | |
11798 return; | |
11799 } | |
11800 pass(); | |
11801 } | |
11802 | |
11803 static void jtt_optimize_VN_Int03() { | |
11804 begin("jtt.optimize.VN_Int03"); | |
11805 String runString = null; | |
11806 try { | |
11807 // (0) == 6 | |
11808 runString = "(0)"; | |
11809 if (6 != jtt.optimize.VN_Int03.test(0)) { | |
11810 fail(runString); | |
11811 return; | |
11812 } | |
11813 // (1) == 0 | |
11814 runString = "(1)"; | |
11815 if (0 != jtt.optimize.VN_Int03.test(1)) { | |
11816 fail(runString); | |
11817 return; | |
11818 } | |
11819 // (2) == 36 | |
11820 runString = "(2)"; | |
11821 if (36 != jtt.optimize.VN_Int03.test(2)) { | |
11822 fail(runString); | |
11823 return; | |
11824 } | |
11825 // (3) == 1 | |
11826 runString = "(3)"; | |
11827 if (1 != jtt.optimize.VN_Int03.test(3)) { | |
11828 fail(runString); | |
11829 return; | |
11830 } | |
11831 // (4) == 0 | |
11832 runString = "(4)"; | |
11833 if (0 != jtt.optimize.VN_Int03.test(4)) { | |
11834 fail(runString); | |
11835 return; | |
11836 } | |
11837 // (5) == 5 | |
11838 runString = "(5)"; | |
11839 if (5 != jtt.optimize.VN_Int03.test(5)) { | |
11840 fail(runString); | |
11841 return; | |
11842 } | |
11843 // (6) == 7 | |
11844 runString = "(6)"; | |
11845 if (7 != jtt.optimize.VN_Int03.test(6)) { | |
11846 fail(runString); | |
11847 return; | |
11848 } | |
11849 // (7) == 0 | |
11850 runString = "(7)"; | |
11851 if (0 != jtt.optimize.VN_Int03.test(7)) { | |
11852 fail(runString); | |
11853 return; | |
11854 } | |
11855 } catch (Throwable t) { | |
11856 fail(runString, t); | |
11857 return; | |
11858 } | |
11859 pass(); | |
11860 } | |
11861 | |
11862 static void jtt_optimize_VN_Long01() { | |
11863 begin("jtt.optimize.VN_Long01"); | |
11864 String runString = null; | |
11865 try { | |
11866 // (0) == 6 | |
11867 runString = "(0)"; | |
11868 if (6L != jtt.optimize.VN_Long01.test(0)) { | |
11869 fail(runString); | |
11870 return; | |
11871 } | |
11872 // (1) == 0 | |
11873 runString = "(1)"; | |
11874 if (0L != jtt.optimize.VN_Long01.test(1)) { | |
11875 fail(runString); | |
11876 return; | |
11877 } | |
11878 // (2) == 36 | |
11879 runString = "(2)"; | |
11880 if (36L != jtt.optimize.VN_Long01.test(2)) { | |
11881 fail(runString); | |
11882 return; | |
11883 } | |
11884 // (3) == 1 | |
11885 runString = "(3)"; | |
11886 if (1L != jtt.optimize.VN_Long01.test(3)) { | |
11887 fail(runString); | |
11888 return; | |
11889 } | |
11890 // (4) == 0 | |
11891 runString = "(4)"; | |
11892 if (0L != jtt.optimize.VN_Long01.test(4)) { | |
11893 fail(runString); | |
11894 return; | |
11895 } | |
11896 // (5) == 5 | |
11897 runString = "(5)"; | |
11898 if (5L != jtt.optimize.VN_Long01.test(5)) { | |
11899 fail(runString); | |
11900 return; | |
11901 } | |
11902 // (6) == 7 | |
11903 runString = "(6)"; | |
11904 if (7L != jtt.optimize.VN_Long01.test(6)) { | |
11905 fail(runString); | |
11906 return; | |
11907 } | |
11908 // (7) == 0 | |
11909 runString = "(7)"; | |
11910 if (0L != jtt.optimize.VN_Long01.test(7)) { | |
11911 fail(runString); | |
11912 return; | |
11913 } | |
11914 } catch (Throwable t) { | |
11915 fail(runString, t); | |
11916 return; | |
11917 } | |
11918 pass(); | |
11919 } | |
11920 | |
11921 static void jtt_optimize_VN_Long02() { | |
11922 begin("jtt.optimize.VN_Long02"); | |
11923 String runString = null; | |
11924 try { | |
11925 // (0) == 10 | |
11926 runString = "(0)"; | |
11927 if (10L != jtt.optimize.VN_Long02.test(0)) { | |
11928 fail(runString); | |
11929 return; | |
11930 } | |
11931 // (1) == 10 | |
11932 runString = "(1)"; | |
11933 if (10L != jtt.optimize.VN_Long02.test(1)) { | |
11934 fail(runString); | |
11935 return; | |
11936 } | |
11937 // (2) == 48 | |
11938 runString = "(2)"; | |
11939 if (48L != jtt.optimize.VN_Long02.test(2)) { | |
11940 fail(runString); | |
11941 return; | |
11942 } | |
11943 } catch (Throwable t) { | |
11944 fail(runString, t); | |
11945 return; | |
11946 } | |
11947 pass(); | |
11948 } | |
11949 | |
11950 static void jtt_optimize_VN_Long03() { | |
11951 begin("jtt.optimize.VN_Long03"); | |
11952 String runString = null; | |
11953 try { | |
11954 // (0) == 6 | |
11955 runString = "(0)"; | |
11956 if (6L != jtt.optimize.VN_Long03.test(0)) { | |
11957 fail(runString); | |
11958 return; | |
11959 } | |
11960 // (1) == 0 | |
11961 runString = "(1)"; | |
11962 if (0L != jtt.optimize.VN_Long03.test(1)) { | |
11963 fail(runString); | |
11964 return; | |
11965 } | |
11966 // (2) == 36 | |
11967 runString = "(2)"; | |
11968 if (36L != jtt.optimize.VN_Long03.test(2)) { | |
11969 fail(runString); | |
11970 return; | |
11971 } | |
11972 // (3) == 1 | |
11973 runString = "(3)"; | |
11974 if (1L != jtt.optimize.VN_Long03.test(3)) { | |
11975 fail(runString); | |
11976 return; | |
11977 } | |
11978 // (4) == 0 | |
11979 runString = "(4)"; | |
11980 if (0L != jtt.optimize.VN_Long03.test(4)) { | |
11981 fail(runString); | |
11982 return; | |
11983 } | |
11984 // (5) == 5 | |
11985 runString = "(5)"; | |
11986 if (5L != jtt.optimize.VN_Long03.test(5)) { | |
11987 fail(runString); | |
11988 return; | |
11989 } | |
11990 // (6) == 7 | |
11991 runString = "(6)"; | |
11992 if (7L != jtt.optimize.VN_Long03.test(6)) { | |
11993 fail(runString); | |
11994 return; | |
11995 } | |
11996 // (7) == 0 | |
11997 runString = "(7)"; | |
11998 if (0L != jtt.optimize.VN_Long03.test(7)) { | |
11999 fail(runString); | |
12000 return; | |
12001 } | |
12002 } catch (Throwable t) { | |
12003 fail(runString, t); | |
12004 return; | |
12005 } | |
12006 pass(); | |
12007 } | |
12008 | |
12009 static void jtt_optimize_VN_Loop01() { | |
12010 begin("jtt.optimize.VN_Loop01"); | |
12011 String runString = null; | |
12012 try { | |
12013 // (0) == 6 | |
12014 runString = "(0)"; | |
12015 if (6 != jtt.optimize.VN_Loop01.test(0)) { | |
12016 fail(runString); | |
12017 return; | |
12018 } | |
12019 // (1) == 8 | |
12020 runString = "(1)"; | |
12021 if (8 != jtt.optimize.VN_Loop01.test(1)) { | |
12022 fail(runString); | |
12023 return; | |
12024 } | |
12025 // (2) == 10 | |
12026 runString = "(2)"; | |
12027 if (10 != jtt.optimize.VN_Loop01.test(2)) { | |
12028 fail(runString); | |
12029 return; | |
12030 } | |
12031 // (3) == 12 | |
12032 runString = "(3)"; | |
12033 if (12 != jtt.optimize.VN_Loop01.test(3)) { | |
12034 fail(runString); | |
12035 return; | |
12036 } | |
12037 // (4) == 0 | |
12038 runString = "(4)"; | |
12039 if (0 != jtt.optimize.VN_Loop01.test(4)) { | |
12040 fail(runString); | |
12041 return; | |
12042 } | |
12043 } catch (Throwable t) { | |
12044 fail(runString, t); | |
12045 return; | |
12046 } | |
12047 pass(); | |
12048 } | |
12049 | |
12050 static void jtt_except_BC_aaload0() { | |
12051 begin("jtt.except.BC_aaload0"); | |
12052 String runString = null; | |
12053 try { | |
12054 // (-2) == !java.lang.NullPointerException | |
12055 try { | |
12056 runString = "(-2)"; | |
12057 jtt.except.BC_aaload0.test(-2); | |
12058 fail(runString); | |
12059 return; | |
12060 } catch (Throwable e) { | |
12061 if (e.getClass() != java.lang.NullPointerException.class) { | |
12062 fail(runString, e); | |
12063 return; | |
12064 } | |
12065 } | |
12066 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
12067 try { | |
12068 runString = "(-1)"; | |
12069 jtt.except.BC_aaload0.test(-1); | |
12070 fail(runString); | |
12071 return; | |
12072 } catch (Throwable e) { | |
12073 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12074 fail(runString, e); | |
12075 return; | |
12076 } | |
12077 } | |
12078 // (0) == null | |
12079 runString = "(0)"; | |
12080 if (null != jtt.except.BC_aaload0.test(0)) { | |
12081 fail(runString); | |
12082 return; | |
12083 } | |
12084 } catch (Throwable t) { | |
12085 fail(runString, t); | |
12086 return; | |
12087 } | |
12088 pass(); | |
12089 } | |
12090 | |
12091 static void jtt_except_BC_aaload1() { | |
12092 begin("jtt.except.BC_aaload1"); | |
12093 String runString = null; | |
12094 try { | |
12095 // (-2) == null | |
12096 runString = "(-2)"; | |
12097 if (null != jtt.except.BC_aaload1.test(-2)) { | |
12098 fail(runString); | |
12099 return; | |
12100 } | |
12101 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
12102 try { | |
12103 runString = "(-1)"; | |
12104 jtt.except.BC_aaload1.test(-1); | |
12105 fail(runString); | |
12106 return; | |
12107 } catch (Throwable e) { | |
12108 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12109 fail(runString, e); | |
12110 return; | |
12111 } | |
12112 } | |
12113 // (0) == null | |
12114 runString = "(0)"; | |
12115 if (null != jtt.except.BC_aaload1.test(0)) { | |
12116 fail(runString); | |
12117 return; | |
12118 } | |
12119 } catch (Throwable t) { | |
12120 fail(runString, t); | |
12121 return; | |
12122 } | |
12123 pass(); | |
12124 } | |
12125 | |
12126 static void jtt_except_BC_aastore0() { | |
12127 begin("jtt.except.BC_aastore0"); | |
12128 String runString = null; | |
12129 try { | |
12130 // (true,-2) == !java.lang.NullPointerException | |
12131 try { | |
12132 runString = "(true,-2)"; | |
12133 jtt.except.BC_aastore0.test(true, -2); | |
12134 fail(runString); | |
12135 return; | |
12136 } catch (Throwable e) { | |
12137 if (e.getClass() != java.lang.NullPointerException.class) { | |
12138 fail(runString, e); | |
12139 return; | |
12140 } | |
12141 } | |
12142 // (true,-1) == !java.lang.ArrayIndexOutOfBoundsException | |
12143 try { | |
12144 runString = "(true,-1)"; | |
12145 jtt.except.BC_aastore0.test(true, -1); | |
12146 fail(runString); | |
12147 return; | |
12148 } catch (Throwable e) { | |
12149 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12150 fail(runString, e); | |
12151 return; | |
12152 } | |
12153 } | |
12154 // (true,0) == 0 | |
12155 runString = "(true,0)"; | |
12156 if (0 != jtt.except.BC_aastore0.test(true, 0)) { | |
12157 fail(runString); | |
12158 return; | |
12159 } | |
12160 // (true,1) == 1 | |
12161 runString = "(true,1)"; | |
12162 if (1 != jtt.except.BC_aastore0.test(true, 1)) { | |
12163 fail(runString); | |
12164 return; | |
12165 } | |
12166 // (true,2) == 2 | |
12167 runString = "(true,2)"; | |
12168 if (2 != jtt.except.BC_aastore0.test(true, 2)) { | |
12169 fail(runString); | |
12170 return; | |
12171 } | |
12172 // (true,3) == !java.lang.ArrayIndexOutOfBoundsException | |
12173 try { | |
12174 runString = "(true,3)"; | |
12175 jtt.except.BC_aastore0.test(true, 3); | |
12176 fail(runString); | |
12177 return; | |
12178 } catch (Throwable e) { | |
12179 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12180 fail(runString, e); | |
12181 return; | |
12182 } | |
12183 } | |
12184 // (false,0) == !java.lang.ArrayStoreException | |
12185 try { | |
12186 runString = "(false,0)"; | |
12187 jtt.except.BC_aastore0.test(false, 0); | |
12188 fail(runString); | |
12189 return; | |
12190 } catch (Throwable e) { | |
12191 if (e.getClass() != java.lang.ArrayStoreException.class) { | |
12192 fail(runString, e); | |
12193 return; | |
12194 } | |
12195 } | |
12196 // (false,1) == 1 | |
12197 runString = "(false,1)"; | |
12198 if (1 != jtt.except.BC_aastore0.test(false, 1)) { | |
12199 fail(runString); | |
12200 return; | |
12201 } | |
12202 // (false,2) == 2 | |
12203 runString = "(false,2)"; | |
12204 if (2 != jtt.except.BC_aastore0.test(false, 2)) { | |
12205 fail(runString); | |
12206 return; | |
12207 } | |
12208 // (false,3) == !java.lang.ArrayIndexOutOfBoundsException | |
12209 try { | |
12210 runString = "(false,3)"; | |
12211 jtt.except.BC_aastore0.test(false, 3); | |
12212 fail(runString); | |
12213 return; | |
12214 } catch (Throwable e) { | |
12215 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12216 fail(runString, e); | |
12217 return; | |
12218 } | |
12219 } | |
12220 } catch (Throwable t) { | |
12221 fail(runString, t); | |
12222 return; | |
12223 } | |
12224 pass(); | |
12225 } | |
12226 | |
12227 static void jtt_except_BC_aastore1() { | |
12228 begin("jtt.except.BC_aastore1"); | |
12229 String runString = null; | |
12230 try { | |
12231 // (true,-2) == 5 | |
12232 runString = "(true,-2)"; | |
12233 if (5 != jtt.except.BC_aastore1.test(true, -2)) { | |
12234 fail(runString); | |
12235 return; | |
12236 } | |
12237 // (true,-1) == !java.lang.ArrayIndexOutOfBoundsException | |
12238 try { | |
12239 runString = "(true,-1)"; | |
12240 jtt.except.BC_aastore1.test(true, -1); | |
12241 fail(runString); | |
12242 return; | |
12243 } catch (Throwable e) { | |
12244 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12245 fail(runString, e); | |
12246 return; | |
12247 } | |
12248 } | |
12249 // (true,0) == 0 | |
12250 runString = "(true,0)"; | |
12251 if (0 != jtt.except.BC_aastore1.test(true, 0)) { | |
12252 fail(runString); | |
12253 return; | |
12254 } | |
12255 // (true,1) == 1 | |
12256 runString = "(true,1)"; | |
12257 if (1 != jtt.except.BC_aastore1.test(true, 1)) { | |
12258 fail(runString); | |
12259 return; | |
12260 } | |
12261 // (true,2) == 2 | |
12262 runString = "(true,2)"; | |
12263 if (2 != jtt.except.BC_aastore1.test(true, 2)) { | |
12264 fail(runString); | |
12265 return; | |
12266 } | |
12267 // (true,3) == !java.lang.ArrayIndexOutOfBoundsException | |
12268 try { | |
12269 runString = "(true,3)"; | |
12270 jtt.except.BC_aastore1.test(true, 3); | |
12271 fail(runString); | |
12272 return; | |
12273 } catch (Throwable e) { | |
12274 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12275 fail(runString, e); | |
12276 return; | |
12277 } | |
12278 } | |
12279 // (false,0) == !java.lang.ArrayStoreException | |
12280 try { | |
12281 runString = "(false,0)"; | |
12282 jtt.except.BC_aastore1.test(false, 0); | |
12283 fail(runString); | |
12284 return; | |
12285 } catch (Throwable e) { | |
12286 if (e.getClass() != java.lang.ArrayStoreException.class) { | |
12287 fail(runString, e); | |
12288 return; | |
12289 } | |
12290 } | |
12291 // (false,1) == 1 | |
12292 runString = "(false,1)"; | |
12293 if (1 != jtt.except.BC_aastore1.test(false, 1)) { | |
12294 fail(runString); | |
12295 return; | |
12296 } | |
12297 // (false,2) == 2 | |
12298 runString = "(false,2)"; | |
12299 if (2 != jtt.except.BC_aastore1.test(false, 2)) { | |
12300 fail(runString); | |
12301 return; | |
12302 } | |
12303 // (false,3) == !java.lang.ArrayIndexOutOfBoundsException | |
12304 try { | |
12305 runString = "(false,3)"; | |
12306 jtt.except.BC_aastore1.test(false, 3); | |
12307 fail(runString); | |
12308 return; | |
12309 } catch (Throwable e) { | |
12310 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12311 fail(runString, e); | |
12312 return; | |
12313 } | |
12314 } | |
12315 } catch (Throwable t) { | |
12316 fail(runString, t); | |
12317 return; | |
12318 } | |
12319 pass(); | |
12320 } | |
12321 | |
12322 static void jtt_except_BC_anewarray() { | |
12323 begin("jtt.except.BC_anewarray"); | |
12324 String runString = null; | |
12325 try { | |
12326 // (-1) == !java.lang.NegativeArraySizeException | |
12327 try { | |
12328 runString = "(-1)"; | |
12329 jtt.except.BC_anewarray.test(-1); | |
12330 fail(runString); | |
12331 return; | |
12332 } catch (Throwable e) { | |
12333 if (e.getClass() != java.lang.NegativeArraySizeException.class) { | |
12334 fail(runString, e); | |
12335 return; | |
12336 } | |
12337 } | |
12338 // (1) == 1 | |
12339 runString = "(1)"; | |
12340 if (1 != jtt.except.BC_anewarray.test(1)) { | |
12341 fail(runString); | |
12342 return; | |
12343 } | |
12344 } catch (Throwable t) { | |
12345 fail(runString, t); | |
12346 return; | |
12347 } | |
12348 pass(); | |
12349 } | |
12350 | |
12351 static void jtt_except_BC_arraylength() { | |
12352 begin("jtt.except.BC_arraylength"); | |
12353 String runString = null; | |
12354 try { | |
12355 // (0) == !java.lang.NullPointerException | |
12356 try { | |
12357 runString = "(0)"; | |
12358 jtt.except.BC_arraylength.test(0); | |
12359 fail(runString); | |
12360 return; | |
12361 } catch (Throwable e) { | |
12362 if (e.getClass() != java.lang.NullPointerException.class) { | |
12363 fail(runString, e); | |
12364 return; | |
12365 } | |
12366 } | |
12367 // (1) == 3 | |
12368 runString = "(1)"; | |
12369 if (3 != jtt.except.BC_arraylength.test(1)) { | |
12370 fail(runString); | |
12371 return; | |
12372 } | |
12373 // (2) == 4 | |
12374 runString = "(2)"; | |
12375 if (4 != jtt.except.BC_arraylength.test(2)) { | |
12376 fail(runString); | |
12377 return; | |
12378 } | |
12379 // (3) == 5 | |
12380 runString = "(3)"; | |
12381 if (5 != jtt.except.BC_arraylength.test(3)) { | |
12382 fail(runString); | |
12383 return; | |
12384 } | |
12385 // (4) == 42 | |
12386 runString = "(4)"; | |
12387 if (42 != jtt.except.BC_arraylength.test(4)) { | |
12388 fail(runString); | |
12389 return; | |
12390 } | |
12391 } catch (Throwable t) { | |
12392 fail(runString, t); | |
12393 return; | |
12394 } | |
12395 pass(); | |
12396 } | |
12397 | |
12398 static void jtt_except_BC_athrow0() { | |
12399 begin("jtt.except.BC_athrow0"); | |
12400 String runString = null; | |
12401 try { | |
12402 // (0) == 0 | |
12403 runString = "(0)"; | |
12404 if (0 != jtt.except.BC_athrow0.test(0)) { | |
12405 fail(runString); | |
12406 return; | |
12407 } | |
12408 // (2) == !java.lang.Throwable | |
12409 try { | |
12410 runString = "(2)"; | |
12411 jtt.except.BC_athrow0.test(2); | |
12412 fail(runString); | |
12413 return; | |
12414 } catch (Throwable e) { | |
12415 if (e.getClass() != java.lang.Throwable.class) { | |
12416 fail(runString, e); | |
12417 return; | |
12418 } | |
12419 } | |
12420 } catch (Throwable t) { | |
12421 fail(runString, t); | |
12422 return; | |
12423 } | |
12424 pass(); | |
12425 } | |
12426 | |
12427 static void jtt_except_BC_athrow1() { | |
12428 begin("jtt.except.BC_athrow1"); | |
12429 String runString = null; | |
12430 try { | |
12431 // (0) == 0 | |
12432 runString = "(0)"; | |
12433 if (0 != jtt.except.BC_athrow1.test(0)) { | |
12434 fail(runString); | |
12435 return; | |
12436 } | |
12437 // (1) == 1 | |
12438 runString = "(1)"; | |
12439 if (1 != jtt.except.BC_athrow1.test(1)) { | |
12440 fail(runString); | |
12441 return; | |
12442 } | |
12443 // (2) == !java.lang.Throwable | |
12444 try { | |
12445 runString = "(2)"; | |
12446 jtt.except.BC_athrow1.test(2); | |
12447 fail(runString); | |
12448 return; | |
12449 } catch (Throwable e) { | |
12450 if (e.getClass() != java.lang.Throwable.class) { | |
12451 fail(runString, e); | |
12452 return; | |
12453 } | |
12454 } | |
12455 // (3) == 3 | |
12456 runString = "(3)"; | |
12457 if (3 != jtt.except.BC_athrow1.test(3)) { | |
12458 fail(runString); | |
12459 return; | |
12460 } | |
12461 } catch (Throwable t) { | |
12462 fail(runString, t); | |
12463 return; | |
12464 } | |
12465 pass(); | |
12466 } | |
12467 | |
12468 static void jtt_except_BC_athrow2() { | |
12469 begin("jtt.except.BC_athrow2"); | |
12470 String runString = null; | |
12471 try { | |
12472 // (0) == 0 | |
12473 runString = "(0)"; | |
12474 if (0 != jtt.except.BC_athrow2.test(0)) { | |
12475 fail(runString); | |
12476 return; | |
12477 } | |
12478 // (2) == !java.lang.Throwable | |
12479 try { | |
12480 runString = "(2)"; | |
12481 jtt.except.BC_athrow2.test(2); | |
12482 fail(runString); | |
12483 return; | |
12484 } catch (Throwable e) { | |
12485 if (e.getClass() != java.lang.Throwable.class) { | |
12486 fail(runString, e); | |
12487 return; | |
12488 } | |
12489 } | |
12490 // (3) == !java.lang.NullPointerException | |
12491 try { | |
12492 runString = "(3)"; | |
12493 jtt.except.BC_athrow2.test(3); | |
12494 fail(runString); | |
12495 return; | |
12496 } catch (Throwable e) { | |
12497 if (e.getClass() != java.lang.NullPointerException.class) { | |
12498 fail(runString, e); | |
12499 return; | |
12500 } | |
12501 } | |
12502 } catch (Throwable t) { | |
12503 fail(runString, t); | |
12504 return; | |
12505 } | |
12506 pass(); | |
12507 } | |
12508 | |
12509 static void jtt_except_BC_athrow3() { | |
12510 begin("jtt.except.BC_athrow3"); | |
12511 String runString = null; | |
12512 try { | |
12513 // (0) == 0 | |
12514 runString = "(0)"; | |
12515 if (0 != jtt.except.BC_athrow3.test(0)) { | |
12516 fail(runString); | |
12517 return; | |
12518 } | |
12519 // (2) == !java.lang.Throwable | |
12520 try { | |
12521 runString = "(2)"; | |
12522 jtt.except.BC_athrow3.test(2); | |
12523 fail(runString); | |
12524 return; | |
12525 } catch (Throwable e) { | |
12526 if (e.getClass() != java.lang.Throwable.class) { | |
12527 fail(runString, e); | |
12528 return; | |
12529 } | |
12530 } | |
12531 // (3) == !java.lang.NullPointerException | |
12532 try { | |
12533 runString = "(3)"; | |
12534 jtt.except.BC_athrow3.test(3); | |
12535 fail(runString); | |
12536 return; | |
12537 } catch (Throwable e) { | |
12538 if (e.getClass() != java.lang.NullPointerException.class) { | |
12539 fail(runString, e); | |
12540 return; | |
12541 } | |
12542 } | |
12543 } catch (Throwable t) { | |
12544 fail(runString, t); | |
12545 return; | |
12546 } | |
12547 pass(); | |
12548 } | |
12549 | |
12550 static void jtt_except_BC_baload() { | |
12551 begin("jtt.except.BC_baload"); | |
12552 String runString = null; | |
12553 try { | |
12554 // (-2) == !java.lang.NullPointerException | |
12555 try { | |
12556 runString = "(-2)"; | |
12557 jtt.except.BC_baload.test(-2); | |
12558 fail(runString); | |
12559 return; | |
12560 } catch (Throwable e) { | |
12561 if (e.getClass() != java.lang.NullPointerException.class) { | |
12562 fail(runString, e); | |
12563 return; | |
12564 } | |
12565 } | |
12566 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
12567 try { | |
12568 runString = "(-1)"; | |
12569 jtt.except.BC_baload.test(-1); | |
12570 fail(runString); | |
12571 return; | |
12572 } catch (Throwable e) { | |
12573 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12574 fail(runString, e); | |
12575 return; | |
12576 } | |
12577 } | |
12578 // (0) == true | |
12579 runString = "(0)"; | |
12580 if (true != jtt.except.BC_baload.test(0)) { | |
12581 fail(runString); | |
12582 return; | |
12583 } | |
12584 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
12585 try { | |
12586 runString = "(4)"; | |
12587 jtt.except.BC_baload.test(4); | |
12588 fail(runString); | |
12589 return; | |
12590 } catch (Throwable e) { | |
12591 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12592 fail(runString, e); | |
12593 return; | |
12594 } | |
12595 } | |
12596 } catch (Throwable t) { | |
12597 fail(runString, t); | |
12598 return; | |
12599 } | |
12600 pass(); | |
12601 } | |
12602 | |
12603 static void jtt_except_BC_bastore() { | |
12604 begin("jtt.except.BC_bastore"); | |
12605 String runString = null; | |
12606 try { | |
12607 // (-2,true) == !java.lang.NullPointerException | |
12608 try { | |
12609 runString = "(-2,true)"; | |
12610 jtt.except.BC_bastore.test(-2, true); | |
12611 fail(runString); | |
12612 return; | |
12613 } catch (Throwable e) { | |
12614 if (e.getClass() != java.lang.NullPointerException.class) { | |
12615 fail(runString, e); | |
12616 return; | |
12617 } | |
12618 } | |
12619 // (-1,false) == !java.lang.ArrayIndexOutOfBoundsException | |
12620 try { | |
12621 runString = "(-1,false)"; | |
12622 jtt.except.BC_bastore.test(-1, false); | |
12623 fail(runString); | |
12624 return; | |
12625 } catch (Throwable e) { | |
12626 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12627 fail(runString, e); | |
12628 return; | |
12629 } | |
12630 } | |
12631 // (0,true) == true | |
12632 runString = "(0,true)"; | |
12633 if (true != jtt.except.BC_bastore.test(0, true)) { | |
12634 fail(runString); | |
12635 return; | |
12636 } | |
12637 // (4,true) == !java.lang.ArrayIndexOutOfBoundsException | |
12638 try { | |
12639 runString = "(4,true)"; | |
12640 jtt.except.BC_bastore.test(4, true); | |
12641 fail(runString); | |
12642 return; | |
12643 } catch (Throwable e) { | |
12644 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12645 fail(runString, e); | |
12646 return; | |
12647 } | |
12648 } | |
12649 } catch (Throwable t) { | |
12650 fail(runString, t); | |
12651 return; | |
12652 } | |
12653 pass(); | |
12654 } | |
12655 | |
12656 static void jtt_except_BC_caload() { | |
12657 begin("jtt.except.BC_caload"); | |
12658 String runString = null; | |
12659 try { | |
12660 // (-2) == !java.lang.NullPointerException | |
12661 try { | |
12662 runString = "(-2)"; | |
12663 jtt.except.BC_caload.test(-2); | |
12664 fail(runString); | |
12665 return; | |
12666 } catch (Throwable e) { | |
12667 if (e.getClass() != java.lang.NullPointerException.class) { | |
12668 fail(runString, e); | |
12669 return; | |
12670 } | |
12671 } | |
12672 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
12673 try { | |
12674 runString = "(-1)"; | |
12675 jtt.except.BC_caload.test(-1); | |
12676 fail(runString); | |
12677 return; | |
12678 } catch (Throwable e) { | |
12679 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12680 fail(runString, e); | |
12681 return; | |
12682 } | |
12683 } | |
12684 // (0) == '\0' | |
12685 runString = "(0)"; | |
12686 if ((char) 0 != jtt.except.BC_caload.test(0)) { | |
12687 fail(runString); | |
12688 return; | |
12689 } | |
12690 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
12691 try { | |
12692 runString = "(4)"; | |
12693 jtt.except.BC_caload.test(4); | |
12694 fail(runString); | |
12695 return; | |
12696 } catch (Throwable e) { | |
12697 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12698 fail(runString, e); | |
12699 return; | |
12700 } | |
12701 } | |
12702 } catch (Throwable t) { | |
12703 fail(runString, t); | |
12704 return; | |
12705 } | |
12706 pass(); | |
12707 } | |
12708 | |
12709 static void jtt_except_BC_castore() { | |
12710 begin("jtt.except.BC_castore"); | |
12711 String runString = null; | |
12712 try { | |
12713 // (-2,'a') == !java.lang.NullPointerException | |
12714 try { | |
12715 runString = "(-2,'a')"; | |
12716 jtt.except.BC_castore.test(-2, (char) 97); | |
12717 fail(runString); | |
12718 return; | |
12719 } catch (Throwable e) { | |
12720 if (e.getClass() != java.lang.NullPointerException.class) { | |
12721 fail(runString, e); | |
12722 return; | |
12723 } | |
12724 } | |
12725 // (-1,'c') == !java.lang.ArrayIndexOutOfBoundsException | |
12726 try { | |
12727 runString = "(-1,'c')"; | |
12728 jtt.except.BC_castore.test(-1, (char) 99); | |
12729 fail(runString); | |
12730 return; | |
12731 } catch (Throwable e) { | |
12732 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12733 fail(runString, e); | |
12734 return; | |
12735 } | |
12736 } | |
12737 // (0,'a') == 'a' | |
12738 runString = "(0,'a')"; | |
12739 if ((char) 97 != jtt.except.BC_castore.test(0, (char) 97)) { | |
12740 fail(runString); | |
12741 return; | |
12742 } | |
12743 // (4,'a') == !java.lang.ArrayIndexOutOfBoundsException | |
12744 try { | |
12745 runString = "(4,'a')"; | |
12746 jtt.except.BC_castore.test(4, (char) 97); | |
12747 fail(runString); | |
12748 return; | |
12749 } catch (Throwable e) { | |
12750 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
12751 fail(runString, e); | |
12752 return; | |
12753 } | |
12754 } | |
12755 } catch (Throwable t) { | |
12756 fail(runString, t); | |
12757 return; | |
12758 } | |
12759 pass(); | |
12760 } | |
12761 | |
12762 static void jtt_except_BC_checkcast() { | |
12763 begin("jtt.except.BC_checkcast"); | |
12764 String runString = null; | |
12765 try { | |
12766 // (0) == 0 | |
12767 runString = "(0)"; | |
12768 if (0 != jtt.except.BC_checkcast.test(0)) { | |
12769 fail(runString); | |
12770 return; | |
12771 } | |
12772 // (2) == !java.lang.ClassCastException | |
12773 try { | |
12774 runString = "(2)"; | |
12775 jtt.except.BC_checkcast.test(2); | |
12776 fail(runString); | |
12777 return; | |
12778 } catch (Throwable e) { | |
12779 if (e.getClass() != java.lang.ClassCastException.class) { | |
12780 fail(runString, e); | |
12781 return; | |
12782 } | |
12783 } | |
12784 // (3) == !java.lang.ClassCastException | |
12785 try { | |
12786 runString = "(3)"; | |
12787 jtt.except.BC_checkcast.test(3); | |
12788 fail(runString); | |
12789 return; | |
12790 } catch (Throwable e) { | |
12791 if (e.getClass() != java.lang.ClassCastException.class) { | |
12792 fail(runString, e); | |
12793 return; | |
12794 } | |
12795 } | |
12796 // (4) == 4 | |
12797 runString = "(4)"; | |
12798 if (4 != jtt.except.BC_checkcast.test(4)) { | |
12799 fail(runString); | |
12800 return; | |
12801 } | |
12802 } catch (Throwable t) { | |
12803 fail(runString, t); | |
12804 return; | |
12805 } | |
12806 pass(); | |
12807 } | |
12808 | |
12809 static void jtt_except_BC_checkcast1() { | |
12810 begin("jtt.except.BC_checkcast1"); | |
12811 String runString = null; | |
12812 try { | |
12813 // (0) == 0 | |
12814 runString = "(0)"; | |
12815 if (0 != jtt.except.BC_checkcast1.test(0)) { | |
12816 fail(runString); | |
12817 return; | |
12818 } | |
12819 // (2) == !java.lang.ClassCastException | |
12820 try { | |
12821 runString = "(2)"; | |
12822 jtt.except.BC_checkcast1.test(2); | |
12823 fail(runString); | |
12824 return; | |
12825 } catch (Throwable e) { | |
12826 if (e.getClass() != java.lang.ClassCastException.class) { | |
12827 fail(runString, e); | |
12828 return; | |
12829 } | |
12830 } | |
12831 // (3) == !java.lang.ClassCastException | |
12832 try { | |
12833 runString = "(3)"; | |
12834 jtt.except.BC_checkcast1.test(3); | |
12835 fail(runString); | |
12836 return; | |
12837 } catch (Throwable e) { | |
12838 if (e.getClass() != java.lang.ClassCastException.class) { | |
12839 fail(runString, e); | |
12840 return; | |
12841 } | |
12842 } | |
12843 // (4) == 4 | |
12844 runString = "(4)"; | |
12845 if (4 != jtt.except.BC_checkcast1.test(4)) { | |
12846 fail(runString); | |
12847 return; | |
12848 } | |
12849 } catch (Throwable t) { | |
12850 fail(runString, t); | |
12851 return; | |
12852 } | |
12853 pass(); | |
12854 } | |
12855 | |
12856 static void jtt_except_BC_checkcast2() { | |
12857 begin("jtt.except.BC_checkcast2"); | |
12858 String runString = null; | |
12859 try { | |
12860 // (0) == -1 | |
12861 runString = "(0)"; | |
12862 if (-1 != jtt.except.BC_checkcast2.test(0)) { | |
12863 fail(runString); | |
12864 return; | |
12865 } | |
12866 // (1) == -1 | |
12867 runString = "(1)"; | |
12868 if (-1 != jtt.except.BC_checkcast2.test(1)) { | |
12869 fail(runString); | |
12870 return; | |
12871 } | |
12872 // (2) == !java.lang.ClassCastException | |
12873 try { | |
12874 runString = "(2)"; | |
12875 jtt.except.BC_checkcast2.test(2); | |
12876 fail(runString); | |
12877 return; | |
12878 } catch (Throwable e) { | |
12879 if (e.getClass() != java.lang.ClassCastException.class) { | |
12880 fail(runString, e); | |
12881 return; | |
12882 } | |
12883 } | |
12884 // (3) == !java.lang.ClassCastException | |
12885 try { | |
12886 runString = "(3)"; | |
12887 jtt.except.BC_checkcast2.test(3); | |
12888 fail(runString); | |
12889 return; | |
12890 } catch (Throwable e) { | |
12891 if (e.getClass() != java.lang.ClassCastException.class) { | |
12892 fail(runString, e); | |
12893 return; | |
12894 } | |
12895 } | |
12896 // (4) == 4 | |
12897 runString = "(4)"; | |
12898 if (4 != jtt.except.BC_checkcast2.test(4)) { | |
12899 fail(runString); | |
12900 return; | |
12901 } | |
12902 } catch (Throwable t) { | |
12903 fail(runString, t); | |
12904 return; | |
12905 } | |
12906 pass(); | |
12907 } | |
12908 | |
12909 static void jtt_except_BC_checkcast3() { | |
12910 begin("jtt.except.BC_checkcast3"); | |
12911 String runString = null; | |
12912 try { | |
12913 // (0) == !java.lang.ClassCastException | |
12914 try { | |
12915 runString = "(0)"; | |
12916 jtt.except.BC_checkcast3.test(0); | |
12917 fail(runString); | |
12918 return; | |
12919 } catch (Throwable e) { | |
12920 if (e.getClass() != java.lang.ClassCastException.class) { | |
12921 fail(runString, e); | |
12922 return; | |
12923 } | |
12924 } | |
12925 // (1) == !java.lang.ClassCastException | |
12926 try { | |
12927 runString = "(1)"; | |
12928 jtt.except.BC_checkcast3.test(1); | |
12929 fail(runString); | |
12930 return; | |
12931 } catch (Throwable e) { | |
12932 if (e.getClass() != java.lang.ClassCastException.class) { | |
12933 fail(runString, e); | |
12934 return; | |
12935 } | |
12936 } | |
12937 // (2) == -1 | |
12938 runString = "(2)"; | |
12939 if (-1 != jtt.except.BC_checkcast3.test(2)) { | |
12940 fail(runString); | |
12941 return; | |
12942 } | |
12943 // (3) == -1 | |
12944 runString = "(3)"; | |
12945 if (-1 != jtt.except.BC_checkcast3.test(3)) { | |
12946 fail(runString); | |
12947 return; | |
12948 } | |
12949 } catch (Throwable t) { | |
12950 fail(runString, t); | |
12951 return; | |
12952 } | |
12953 pass(); | |
12954 } | |
12955 | |
12956 static void jtt_except_BC_checkcast4() { | |
12957 begin("jtt.except.BC_checkcast4"); | |
12958 String runString = null; | |
12959 try { | |
12960 // (0) == -1 | |
12961 runString = "(0)"; | |
12962 if (-1 != jtt.except.BC_checkcast4.test(0)) { | |
12963 fail(runString); | |
12964 return; | |
12965 } | |
12966 // (1) == -1 | |
12967 runString = "(1)"; | |
12968 if (-1 != jtt.except.BC_checkcast4.test(1)) { | |
12969 fail(runString); | |
12970 return; | |
12971 } | |
12972 // (2) == !java.lang.ClassCastException | |
12973 try { | |
12974 runString = "(2)"; | |
12975 jtt.except.BC_checkcast4.test(2); | |
12976 fail(runString); | |
12977 return; | |
12978 } catch (Throwable e) { | |
12979 if (e.getClass() != java.lang.ClassCastException.class) { | |
12980 fail(runString, e); | |
12981 return; | |
12982 } | |
12983 } | |
12984 // (3) == !java.lang.ClassCastException | |
12985 try { | |
12986 runString = "(3)"; | |
12987 jtt.except.BC_checkcast4.test(3); | |
12988 fail(runString); | |
12989 return; | |
12990 } catch (Throwable e) { | |
12991 if (e.getClass() != java.lang.ClassCastException.class) { | |
12992 fail(runString, e); | |
12993 return; | |
12994 } | |
12995 } | |
12996 // (4) == 4 | |
12997 runString = "(4)"; | |
12998 if (4 != jtt.except.BC_checkcast4.test(4)) { | |
12999 fail(runString); | |
13000 return; | |
13001 } | |
13002 } catch (Throwable t) { | |
13003 fail(runString, t); | |
13004 return; | |
13005 } | |
13006 pass(); | |
13007 } | |
13008 | |
13009 static void jtt_except_BC_checkcast5() { | |
13010 begin("jtt.except.BC_checkcast5"); | |
13011 String runString = null; | |
13012 try { | |
13013 // (0) == -1 | |
13014 runString = "(0)"; | |
13015 if (-1 != jtt.except.BC_checkcast5.test(0)) { | |
13016 fail(runString); | |
13017 return; | |
13018 } | |
13019 // (1) == -1 | |
13020 runString = "(1)"; | |
13021 if (-1 != jtt.except.BC_checkcast5.test(1)) { | |
13022 fail(runString); | |
13023 return; | |
13024 } | |
13025 // (2) == -5 | |
13026 runString = "(2)"; | |
13027 if (-5 != jtt.except.BC_checkcast5.test(2)) { | |
13028 fail(runString); | |
13029 return; | |
13030 } | |
13031 // (3) == -5 | |
13032 runString = "(3)"; | |
13033 if (-5 != jtt.except.BC_checkcast5.test(3)) { | |
13034 fail(runString); | |
13035 return; | |
13036 } | |
13037 // (4) == 4 | |
13038 runString = "(4)"; | |
13039 if (4 != jtt.except.BC_checkcast5.test(4)) { | |
13040 fail(runString); | |
13041 return; | |
13042 } | |
13043 } catch (Throwable t) { | |
13044 fail(runString, t); | |
13045 return; | |
13046 } | |
13047 pass(); | |
13048 } | |
13049 | |
13050 static void jtt_except_BC_checkcast6() { | |
13051 begin("jtt.except.BC_checkcast6"); | |
13052 String runString = null; | |
13053 try { | |
13054 // (0) == -1 | |
13055 runString = "(0)"; | |
13056 if (-1 != jtt.except.BC_checkcast6.test(0)) { | |
13057 fail(runString); | |
13058 return; | |
13059 } | |
13060 // (1) == -1 | |
13061 runString = "(1)"; | |
13062 if (-1 != jtt.except.BC_checkcast6.test(1)) { | |
13063 fail(runString); | |
13064 return; | |
13065 } | |
13066 // (2) == -5 | |
13067 runString = "(2)"; | |
13068 if (-5 != jtt.except.BC_checkcast6.test(2)) { | |
13069 fail(runString); | |
13070 return; | |
13071 } | |
13072 // (3) == -5 | |
13073 runString = "(3)"; | |
13074 if (-5 != jtt.except.BC_checkcast6.test(3)) { | |
13075 fail(runString); | |
13076 return; | |
13077 } | |
13078 // (4) == 4 | |
13079 runString = "(4)"; | |
13080 if (4 != jtt.except.BC_checkcast6.test(4)) { | |
13081 fail(runString); | |
13082 return; | |
13083 } | |
13084 } catch (Throwable t) { | |
13085 fail(runString, t); | |
13086 return; | |
13087 } | |
13088 pass(); | |
13089 } | |
13090 | |
13091 static void jtt_except_BC_daload() { | |
13092 begin("jtt.except.BC_daload"); | |
13093 String runString = null; | |
13094 try { | |
13095 // (-2) == !java.lang.NullPointerException | |
13096 try { | |
13097 runString = "(-2)"; | |
13098 jtt.except.BC_daload.test(-2); | |
13099 fail(runString); | |
13100 return; | |
13101 } catch (Throwable e) { | |
13102 if (e.getClass() != java.lang.NullPointerException.class) { | |
13103 fail(runString, e); | |
13104 return; | |
13105 } | |
13106 } | |
13107 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
13108 try { | |
13109 runString = "(-1)"; | |
13110 jtt.except.BC_daload.test(-1); | |
13111 fail(runString); | |
13112 return; | |
13113 } catch (Throwable e) { | |
13114 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13115 fail(runString, e); | |
13116 return; | |
13117 } | |
13118 } | |
13119 // (0) == 0.0 | |
13120 runString = "(0)"; | |
13121 if (0.0 != jtt.except.BC_daload.test(0)) { | |
13122 fail(runString); | |
13123 return; | |
13124 } | |
13125 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
13126 try { | |
13127 runString = "(4)"; | |
13128 jtt.except.BC_daload.test(4); | |
13129 fail(runString); | |
13130 return; | |
13131 } catch (Throwable e) { | |
13132 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13133 fail(runString, e); | |
13134 return; | |
13135 } | |
13136 } | |
13137 } catch (Throwable t) { | |
13138 fail(runString, t); | |
13139 return; | |
13140 } | |
13141 pass(); | |
13142 } | |
13143 | |
13144 static void jtt_except_BC_dastore() { | |
13145 begin("jtt.except.BC_dastore"); | |
13146 String runString = null; | |
13147 try { | |
13148 // (-2,0.01) == !java.lang.NullPointerException | |
13149 try { | |
13150 runString = "(-2,0.01)"; | |
13151 jtt.except.BC_dastore.test(-2, 0.01); | |
13152 fail(runString); | |
13153 return; | |
13154 } catch (Throwable e) { | |
13155 if (e.getClass() != java.lang.NullPointerException.class) { | |
13156 fail(runString, e); | |
13157 return; | |
13158 } | |
13159 } | |
13160 // (-1,-1.4) == !java.lang.ArrayIndexOutOfBoundsException | |
13161 try { | |
13162 runString = "(-1,-1.4)"; | |
13163 jtt.except.BC_dastore.test(-1, -1.4); | |
13164 fail(runString); | |
13165 return; | |
13166 } catch (Throwable e) { | |
13167 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13168 fail(runString, e); | |
13169 return; | |
13170 } | |
13171 } | |
13172 // (0,0.01) == 0.01 | |
13173 runString = "(0,0.01)"; | |
13174 if (0.01 != jtt.except.BC_dastore.test(0, 0.01)) { | |
13175 fail(runString); | |
13176 return; | |
13177 } | |
13178 // (4,0.01) == !java.lang.ArrayIndexOutOfBoundsException | |
13179 try { | |
13180 runString = "(4,0.01)"; | |
13181 jtt.except.BC_dastore.test(4, 0.01); | |
13182 fail(runString); | |
13183 return; | |
13184 } catch (Throwable e) { | |
13185 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13186 fail(runString, e); | |
13187 return; | |
13188 } | |
13189 } | |
13190 } catch (Throwable t) { | |
13191 fail(runString, t); | |
13192 return; | |
13193 } | |
13194 pass(); | |
13195 } | |
13196 | |
13197 static void jtt_except_BC_faload() { | |
13198 begin("jtt.except.BC_faload"); | |
13199 String runString = null; | |
13200 try { | |
13201 // (-2) == !java.lang.NullPointerException | |
13202 try { | |
13203 runString = "(-2)"; | |
13204 jtt.except.BC_faload.test(-2); | |
13205 fail(runString); | |
13206 return; | |
13207 } catch (Throwable e) { | |
13208 if (e.getClass() != java.lang.NullPointerException.class) { | |
13209 fail(runString, e); | |
13210 return; | |
13211 } | |
13212 } | |
13213 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
13214 try { | |
13215 runString = "(-1)"; | |
13216 jtt.except.BC_faload.test(-1); | |
13217 fail(runString); | |
13218 return; | |
13219 } catch (Throwable e) { | |
13220 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13221 fail(runString, e); | |
13222 return; | |
13223 } | |
13224 } | |
13225 // (0) == 0.0 | |
13226 runString = "(0)"; | |
13227 if (0.0f != jtt.except.BC_faload.test(0)) { | |
13228 fail(runString); | |
13229 return; | |
13230 } | |
13231 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
13232 try { | |
13233 runString = "(4)"; | |
13234 jtt.except.BC_faload.test(4); | |
13235 fail(runString); | |
13236 return; | |
13237 } catch (Throwable e) { | |
13238 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13239 fail(runString, e); | |
13240 return; | |
13241 } | |
13242 } | |
13243 } catch (Throwable t) { | |
13244 fail(runString, t); | |
13245 return; | |
13246 } | |
13247 pass(); | |
13248 } | |
13249 | |
13250 static void jtt_except_BC_fastore() { | |
13251 begin("jtt.except.BC_fastore"); | |
13252 String runString = null; | |
13253 try { | |
13254 // (-2,0.01) == !java.lang.NullPointerException | |
13255 try { | |
13256 runString = "(-2,0.01)"; | |
13257 jtt.except.BC_fastore.test(-2, 0.01f); | |
13258 fail(runString); | |
13259 return; | |
13260 } catch (Throwable e) { | |
13261 if (e.getClass() != java.lang.NullPointerException.class) { | |
13262 fail(runString, e); | |
13263 return; | |
13264 } | |
13265 } | |
13266 // (-1,-1.4) == !java.lang.ArrayIndexOutOfBoundsException | |
13267 try { | |
13268 runString = "(-1,-1.4)"; | |
13269 jtt.except.BC_fastore.test(-1, -1.4f); | |
13270 fail(runString); | |
13271 return; | |
13272 } catch (Throwable e) { | |
13273 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13274 fail(runString, e); | |
13275 return; | |
13276 } | |
13277 } | |
13278 // (0,0.01) == 0.01 | |
13279 runString = "(0,0.01)"; | |
13280 if (0.01f != jtt.except.BC_fastore.test(0, 0.01f)) { | |
13281 fail(runString); | |
13282 return; | |
13283 } | |
13284 // (4,0.01) == !java.lang.ArrayIndexOutOfBoundsException | |
13285 try { | |
13286 runString = "(4,0.01)"; | |
13287 jtt.except.BC_fastore.test(4, 0.01f); | |
13288 fail(runString); | |
13289 return; | |
13290 } catch (Throwable e) { | |
13291 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13292 fail(runString, e); | |
13293 return; | |
13294 } | |
13295 } | |
13296 } catch (Throwable t) { | |
13297 fail(runString, t); | |
13298 return; | |
13299 } | |
13300 pass(); | |
13301 } | |
13302 | |
13303 static void jtt_except_BC_getfield() { | |
13304 begin("jtt.except.BC_getfield"); | |
13305 String runString = null; | |
13306 try { | |
13307 // (0) == 13 | |
13308 runString = "(0)"; | |
13309 if (13 != jtt.except.BC_getfield.test(0)) { | |
13310 fail(runString); | |
13311 return; | |
13312 } | |
13313 // (3) == !java.lang.NullPointerException | |
13314 try { | |
13315 runString = "(3)"; | |
13316 jtt.except.BC_getfield.test(3); | |
13317 fail(runString); | |
13318 return; | |
13319 } catch (Throwable e) { | |
13320 if (e.getClass() != java.lang.NullPointerException.class) { | |
13321 fail(runString, e); | |
13322 return; | |
13323 } | |
13324 } | |
13325 } catch (Throwable t) { | |
13326 fail(runString, t); | |
13327 return; | |
13328 } | |
13329 pass(); | |
13330 } | |
13331 | |
13332 static void jtt_except_BC_iaload() { | |
13333 begin("jtt.except.BC_iaload"); | |
13334 String runString = null; | |
13335 try { | |
13336 // (-2) == !java.lang.NullPointerException | |
13337 try { | |
13338 runString = "(-2)"; | |
13339 jtt.except.BC_iaload.test(-2); | |
13340 fail(runString); | |
13341 return; | |
13342 } catch (Throwable e) { | |
13343 if (e.getClass() != java.lang.NullPointerException.class) { | |
13344 fail(runString, e); | |
13345 return; | |
13346 } | |
13347 } | |
13348 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
13349 try { | |
13350 runString = "(-1)"; | |
13351 jtt.except.BC_iaload.test(-1); | |
13352 fail(runString); | |
13353 return; | |
13354 } catch (Throwable e) { | |
13355 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13356 fail(runString, e); | |
13357 return; | |
13358 } | |
13359 } | |
13360 // (0) == 0 | |
13361 runString = "(0)"; | |
13362 if (0 != jtt.except.BC_iaload.test(0)) { | |
13363 fail(runString); | |
13364 return; | |
13365 } | |
13366 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
13367 try { | |
13368 runString = "(4)"; | |
13369 jtt.except.BC_iaload.test(4); | |
13370 fail(runString); | |
13371 return; | |
13372 } catch (Throwable e) { | |
13373 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13374 fail(runString, e); | |
13375 return; | |
13376 } | |
13377 } | |
13378 } catch (Throwable t) { | |
13379 fail(runString, t); | |
13380 return; | |
13381 } | |
13382 pass(); | |
13383 } | |
13384 | |
13385 static void jtt_except_BC_iastore() { | |
13386 begin("jtt.except.BC_iastore"); | |
13387 String runString = null; | |
13388 try { | |
13389 // (-2,0) == !java.lang.NullPointerException | |
13390 try { | |
13391 runString = "(-2,0)"; | |
13392 jtt.except.BC_iastore.test(-2, 0); | |
13393 fail(runString); | |
13394 return; | |
13395 } catch (Throwable e) { | |
13396 if (e.getClass() != java.lang.NullPointerException.class) { | |
13397 fail(runString, e); | |
13398 return; | |
13399 } | |
13400 } | |
13401 // (-1,3) == !java.lang.ArrayIndexOutOfBoundsException | |
13402 try { | |
13403 runString = "(-1,3)"; | |
13404 jtt.except.BC_iastore.test(-1, 3); | |
13405 fail(runString); | |
13406 return; | |
13407 } catch (Throwable e) { | |
13408 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13409 fail(runString, e); | |
13410 return; | |
13411 } | |
13412 } | |
13413 // (0,0) == 0 | |
13414 runString = "(0,0)"; | |
13415 if (0 != jtt.except.BC_iastore.test(0, 0)) { | |
13416 fail(runString); | |
13417 return; | |
13418 } | |
13419 // (4,0) == !java.lang.ArrayIndexOutOfBoundsException | |
13420 try { | |
13421 runString = "(4,0)"; | |
13422 jtt.except.BC_iastore.test(4, 0); | |
13423 fail(runString); | |
13424 return; | |
13425 } catch (Throwable e) { | |
13426 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13427 fail(runString, e); | |
13428 return; | |
13429 } | |
13430 } | |
13431 } catch (Throwable t) { | |
13432 fail(runString, t); | |
13433 return; | |
13434 } | |
13435 pass(); | |
13436 } | |
13437 | |
13438 static void jtt_except_BC_idiv() { | |
13439 begin("jtt.except.BC_idiv"); | |
13440 String runString = null; | |
13441 try { | |
13442 // (1,2) == 0 | |
13443 runString = "(1,2)"; | |
13444 if (0 != jtt.except.BC_idiv.test(1, 2)) { | |
13445 fail(runString); | |
13446 return; | |
13447 } | |
13448 // (11,0) == !java.lang.ArithmeticException | |
13449 try { | |
13450 runString = "(11,0)"; | |
13451 jtt.except.BC_idiv.test(11, 0); | |
13452 fail(runString); | |
13453 return; | |
13454 } catch (Throwable e) { | |
13455 if (e.getClass() != java.lang.ArithmeticException.class) { | |
13456 fail(runString, e); | |
13457 return; | |
13458 } | |
13459 } | |
13460 } catch (Throwable t) { | |
13461 fail(runString, t); | |
13462 return; | |
13463 } | |
13464 pass(); | |
13465 } | |
13466 | |
13467 static void jtt_except_BC_idiv2() { | |
13468 begin("jtt.except.BC_idiv2"); | |
13469 String runString = null; | |
13470 try { | |
13471 // (1,2) == 0 | |
13472 runString = "(1,2)"; | |
13473 if (0 != jtt.except.BC_idiv2.test(1, 2)) { | |
13474 fail(runString); | |
13475 return; | |
13476 } | |
13477 // (11,0) == -11 | |
13478 runString = "(11,0)"; | |
13479 if (-11 != jtt.except.BC_idiv2.test(11, 0)) { | |
13480 fail(runString); | |
13481 return; | |
13482 } | |
13483 } catch (Throwable t) { | |
13484 fail(runString, t); | |
13485 return; | |
13486 } | |
13487 pass(); | |
13488 } | |
13489 | |
13490 static void jtt_except_BC_invokespecial01() { | |
13491 begin("jtt.except.BC_invokespecial01"); | |
13492 String runString = null; | |
13493 try { | |
13494 // (0) == true | |
13495 runString = "(0)"; | |
13496 if (true != jtt.except.BC_invokespecial01.test(0)) { | |
13497 fail(runString); | |
13498 return; | |
13499 } | |
13500 // (1) == !java.lang.NullPointerException | |
13501 try { | |
13502 runString = "(1)"; | |
13503 jtt.except.BC_invokespecial01.test(1); | |
13504 fail(runString); | |
13505 return; | |
13506 } catch (Throwable e) { | |
13507 if (e.getClass() != java.lang.NullPointerException.class) { | |
13508 fail(runString, e); | |
13509 return; | |
13510 } | |
13511 } | |
13512 } catch (Throwable t) { | |
13513 fail(runString, t); | |
13514 return; | |
13515 } | |
13516 pass(); | |
13517 } | |
13518 | |
13519 static void jtt_except_BC_invokevirtual01() { | |
13520 begin("jtt.except.BC_invokevirtual01"); | |
13521 String runString = null; | |
13522 try { | |
13523 // (0) == true | |
13524 runString = "(0)"; | |
13525 if (true != jtt.except.BC_invokevirtual01.test(0)) { | |
13526 fail(runString); | |
13527 return; | |
13528 } | |
13529 // (1) == !java.lang.NullPointerException | |
13530 try { | |
13531 runString = "(1)"; | |
13532 jtt.except.BC_invokevirtual01.test(1); | |
13533 fail(runString); | |
13534 return; | |
13535 } catch (Throwable e) { | |
13536 if (e.getClass() != java.lang.NullPointerException.class) { | |
13537 fail(runString, e); | |
13538 return; | |
13539 } | |
13540 } | |
13541 } catch (Throwable t) { | |
13542 fail(runString, t); | |
13543 return; | |
13544 } | |
13545 pass(); | |
13546 } | |
13547 | |
13548 static void jtt_except_BC_invokevirtual02() { | |
13549 begin("jtt.except.BC_invokevirtual02"); | |
13550 String runString = null; | |
13551 try { | |
13552 // (0) == true | |
13553 runString = "(0)"; | |
13554 if (true != jtt.except.BC_invokevirtual02.test(0)) { | |
13555 fail(runString); | |
13556 return; | |
13557 } | |
13558 // (1) == !java.lang.NullPointerException | |
13559 try { | |
13560 runString = "(1)"; | |
13561 jtt.except.BC_invokevirtual02.test(1); | |
13562 fail(runString); | |
13563 return; | |
13564 } catch (Throwable e) { | |
13565 if (e.getClass() != java.lang.NullPointerException.class) { | |
13566 fail(runString, e); | |
13567 return; | |
13568 } | |
13569 } | |
13570 } catch (Throwable t) { | |
13571 fail(runString, t); | |
13572 return; | |
13573 } | |
13574 pass(); | |
13575 } | |
13576 | |
13577 static void jtt_except_BC_irem() { | |
13578 begin("jtt.except.BC_irem"); | |
13579 String runString = null; | |
13580 try { | |
13581 // (1,2) == 1 | |
13582 runString = "(1,2)"; | |
13583 if (1 != jtt.except.BC_irem.test(1, 2)) { | |
13584 fail(runString); | |
13585 return; | |
13586 } | |
13587 // (11,0) == !java.lang.ArithmeticException | |
13588 try { | |
13589 runString = "(11,0)"; | |
13590 jtt.except.BC_irem.test(11, 0); | |
13591 fail(runString); | |
13592 return; | |
13593 } catch (Throwable e) { | |
13594 if (e.getClass() != java.lang.ArithmeticException.class) { | |
13595 fail(runString, e); | |
13596 return; | |
13597 } | |
13598 } | |
13599 } catch (Throwable t) { | |
13600 fail(runString, t); | |
13601 return; | |
13602 } | |
13603 pass(); | |
13604 } | |
13605 | |
13606 static void jtt_except_BC_laload() { | |
13607 begin("jtt.except.BC_laload"); | |
13608 String runString = null; | |
13609 try { | |
13610 // (-2) == !java.lang.NullPointerException | |
13611 try { | |
13612 runString = "(-2)"; | |
13613 jtt.except.BC_laload.test(-2); | |
13614 fail(runString); | |
13615 return; | |
13616 } catch (Throwable e) { | |
13617 if (e.getClass() != java.lang.NullPointerException.class) { | |
13618 fail(runString, e); | |
13619 return; | |
13620 } | |
13621 } | |
13622 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
13623 try { | |
13624 runString = "(-1)"; | |
13625 jtt.except.BC_laload.test(-1); | |
13626 fail(runString); | |
13627 return; | |
13628 } catch (Throwable e) { | |
13629 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13630 fail(runString, e); | |
13631 return; | |
13632 } | |
13633 } | |
13634 // (0) == 0 | |
13635 runString = "(0)"; | |
13636 if (0L != jtt.except.BC_laload.test(0)) { | |
13637 fail(runString); | |
13638 return; | |
13639 } | |
13640 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
13641 try { | |
13642 runString = "(4)"; | |
13643 jtt.except.BC_laload.test(4); | |
13644 fail(runString); | |
13645 return; | |
13646 } catch (Throwable e) { | |
13647 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13648 fail(runString, e); | |
13649 return; | |
13650 } | |
13651 } | |
13652 } catch (Throwable t) { | |
13653 fail(runString, t); | |
13654 return; | |
13655 } | |
13656 pass(); | |
13657 } | |
13658 | |
13659 static void jtt_except_BC_lastore() { | |
13660 begin("jtt.except.BC_lastore"); | |
13661 String runString = null; | |
13662 try { | |
13663 // (-2,0) == !java.lang.NullPointerException | |
13664 try { | |
13665 runString = "(-2,0)"; | |
13666 jtt.except.BC_lastore.test(-2, 0L); | |
13667 fail(runString); | |
13668 return; | |
13669 } catch (Throwable e) { | |
13670 if (e.getClass() != java.lang.NullPointerException.class) { | |
13671 fail(runString, e); | |
13672 return; | |
13673 } | |
13674 } | |
13675 // (-1,3) == !java.lang.ArrayIndexOutOfBoundsException | |
13676 try { | |
13677 runString = "(-1,3)"; | |
13678 jtt.except.BC_lastore.test(-1, 3L); | |
13679 fail(runString); | |
13680 return; | |
13681 } catch (Throwable e) { | |
13682 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13683 fail(runString, e); | |
13684 return; | |
13685 } | |
13686 } | |
13687 // (0,0) == 0 | |
13688 runString = "(0,0)"; | |
13689 if (0L != jtt.except.BC_lastore.test(0, 0L)) { | |
13690 fail(runString); | |
13691 return; | |
13692 } | |
13693 // (4,0) == !java.lang.ArrayIndexOutOfBoundsException | |
13694 try { | |
13695 runString = "(4,0)"; | |
13696 jtt.except.BC_lastore.test(4, 0L); | |
13697 fail(runString); | |
13698 return; | |
13699 } catch (Throwable e) { | |
13700 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13701 fail(runString, e); | |
13702 return; | |
13703 } | |
13704 } | |
13705 } catch (Throwable t) { | |
13706 fail(runString, t); | |
13707 return; | |
13708 } | |
13709 pass(); | |
13710 } | |
13711 | |
13712 static void jtt_except_BC_ldiv() { | |
13713 begin("jtt.except.BC_ldiv"); | |
13714 String runString = null; | |
13715 try { | |
13716 // (1,2) == 0 | |
13717 runString = "(1,2)"; | |
13718 if (0L != jtt.except.BC_ldiv.test(1L, 2L)) { | |
13719 fail(runString); | |
13720 return; | |
13721 } | |
13722 // (11,0) == !java.lang.ArithmeticException | |
13723 try { | |
13724 runString = "(11,0)"; | |
13725 jtt.except.BC_ldiv.test(11L, 0L); | |
13726 fail(runString); | |
13727 return; | |
13728 } catch (Throwable e) { | |
13729 if (e.getClass() != java.lang.ArithmeticException.class) { | |
13730 fail(runString, e); | |
13731 return; | |
13732 } | |
13733 } | |
13734 } catch (Throwable t) { | |
13735 fail(runString, t); | |
13736 return; | |
13737 } | |
13738 pass(); | |
13739 } | |
13740 | |
13741 static void jtt_except_BC_ldiv2() { | |
13742 begin("jtt.except.BC_ldiv2"); | |
13743 String runString = null; | |
13744 try { | |
13745 // (1,2) == 0 | |
13746 runString = "(1,2)"; | |
13747 if (0L != jtt.except.BC_ldiv2.test(1L, 2L)) { | |
13748 fail(runString); | |
13749 return; | |
13750 } | |
13751 // (11,0) == -11 | |
13752 runString = "(11,0)"; | |
13753 if (-11L != jtt.except.BC_ldiv2.test(11L, 0L)) { | |
13754 fail(runString); | |
13755 return; | |
13756 } | |
13757 } catch (Throwable t) { | |
13758 fail(runString, t); | |
13759 return; | |
13760 } | |
13761 pass(); | |
13762 } | |
13763 | |
13764 static void jtt_except_BC_lrem() { | |
13765 begin("jtt.except.BC_lrem"); | |
13766 String runString = null; | |
13767 try { | |
13768 // (1,2) == 1 | |
13769 runString = "(1,2)"; | |
13770 if (1L != jtt.except.BC_lrem.test(1L, 2L)) { | |
13771 fail(runString); | |
13772 return; | |
13773 } | |
13774 // (11,0) == !java.lang.ArithmeticException | |
13775 try { | |
13776 runString = "(11,0)"; | |
13777 jtt.except.BC_lrem.test(11L, 0L); | |
13778 fail(runString); | |
13779 return; | |
13780 } catch (Throwable e) { | |
13781 if (e.getClass() != java.lang.ArithmeticException.class) { | |
13782 fail(runString, e); | |
13783 return; | |
13784 } | |
13785 } | |
13786 } catch (Throwable t) { | |
13787 fail(runString, t); | |
13788 return; | |
13789 } | |
13790 pass(); | |
13791 } | |
13792 | |
13793 static void jtt_except_BC_monitorenter() { | |
13794 begin("jtt.except.BC_monitorenter"); | |
13795 String runString = null; | |
13796 try { | |
13797 // (true) == true | |
13798 runString = "(true)"; | |
13799 if (true != jtt.except.BC_monitorenter.test(true)) { | |
13800 fail(runString); | |
13801 return; | |
13802 } | |
13803 // (false) == !java.lang.NullPointerException | |
13804 try { | |
13805 runString = "(false)"; | |
13806 jtt.except.BC_monitorenter.test(false); | |
13807 fail(runString); | |
13808 return; | |
13809 } catch (Throwable e) { | |
13810 if (e.getClass() != java.lang.NullPointerException.class) { | |
13811 fail(runString, e); | |
13812 return; | |
13813 } | |
13814 } | |
13815 } catch (Throwable t) { | |
13816 fail(runString, t); | |
13817 return; | |
13818 } | |
13819 pass(); | |
13820 } | |
13821 | |
13822 static void jtt_except_BC_multianewarray() { | |
13823 begin("jtt.except.BC_multianewarray"); | |
13824 String runString = null; | |
13825 try { | |
13826 // (0,0) == 0 | |
13827 runString = "(0,0)"; | |
13828 if (0 != jtt.except.BC_multianewarray.test(0, 0)) { | |
13829 fail(runString); | |
13830 return; | |
13831 } | |
13832 // (1,1) == 1 | |
13833 runString = "(1,1)"; | |
13834 if (1 != jtt.except.BC_multianewarray.test(1, 1)) { | |
13835 fail(runString); | |
13836 return; | |
13837 } | |
13838 // (-1,0) == !java.lang.NegativeArraySizeException | |
13839 try { | |
13840 runString = "(-1,0)"; | |
13841 jtt.except.BC_multianewarray.test(-1, 0); | |
13842 fail(runString); | |
13843 return; | |
13844 } catch (Throwable e) { | |
13845 if (e.getClass() != java.lang.NegativeArraySizeException.class) { | |
13846 fail(runString, e); | |
13847 return; | |
13848 } | |
13849 } | |
13850 // (0,-1) == !java.lang.NegativeArraySizeException | |
13851 try { | |
13852 runString = "(0,-1)"; | |
13853 jtt.except.BC_multianewarray.test(0, -1); | |
13854 fail(runString); | |
13855 return; | |
13856 } catch (Throwable e) { | |
13857 if (e.getClass() != java.lang.NegativeArraySizeException.class) { | |
13858 fail(runString, e); | |
13859 return; | |
13860 } | |
13861 } | |
13862 } catch (Throwable t) { | |
13863 fail(runString, t); | |
13864 return; | |
13865 } | |
13866 pass(); | |
13867 } | |
13868 | |
13869 static void jtt_except_BC_newarray() { | |
13870 begin("jtt.except.BC_newarray"); | |
13871 String runString = null; | |
13872 try { | |
13873 // (-1) == !java.lang.NegativeArraySizeException | |
13874 try { | |
13875 runString = "(-1)"; | |
13876 jtt.except.BC_newarray.test(-1); | |
13877 fail(runString); | |
13878 return; | |
13879 } catch (Throwable e) { | |
13880 if (e.getClass() != java.lang.NegativeArraySizeException.class) { | |
13881 fail(runString, e); | |
13882 return; | |
13883 } | |
13884 } | |
13885 // (0) == 0 | |
13886 runString = "(0)"; | |
13887 if (0 != jtt.except.BC_newarray.test(0)) { | |
13888 fail(runString); | |
13889 return; | |
13890 } | |
13891 // (1) == 1 | |
13892 runString = "(1)"; | |
13893 if (1 != jtt.except.BC_newarray.test(1)) { | |
13894 fail(runString); | |
13895 return; | |
13896 } | |
13897 } catch (Throwable t) { | |
13898 fail(runString, t); | |
13899 return; | |
13900 } | |
13901 pass(); | |
13902 } | |
13903 | |
13904 static void jtt_except_BC_putfield() { | |
13905 begin("jtt.except.BC_putfield"); | |
13906 String runString = null; | |
13907 try { | |
13908 // (0) == 0 | |
13909 runString = "(0)"; | |
13910 if (0 != jtt.except.BC_putfield.test(0)) { | |
13911 fail(runString); | |
13912 return; | |
13913 } | |
13914 // (3) == !java.lang.NullPointerException | |
13915 try { | |
13916 runString = "(3)"; | |
13917 jtt.except.BC_putfield.test(3); | |
13918 fail(runString); | |
13919 return; | |
13920 } catch (Throwable e) { | |
13921 if (e.getClass() != java.lang.NullPointerException.class) { | |
13922 fail(runString, e); | |
13923 return; | |
13924 } | |
13925 } | |
13926 // (-4) == -4 | |
13927 runString = "(-4)"; | |
13928 if (-4 != jtt.except.BC_putfield.test(-4)) { | |
13929 fail(runString); | |
13930 return; | |
13931 } | |
13932 } catch (Throwable t) { | |
13933 fail(runString, t); | |
13934 return; | |
13935 } | |
13936 pass(); | |
13937 } | |
13938 | |
13939 static void jtt_except_BC_saload() { | |
13940 begin("jtt.except.BC_saload"); | |
13941 String runString = null; | |
13942 try { | |
13943 // (-2) == !java.lang.NullPointerException | |
13944 try { | |
13945 runString = "(-2)"; | |
13946 jtt.except.BC_saload.test(-2); | |
13947 fail(runString); | |
13948 return; | |
13949 } catch (Throwable e) { | |
13950 if (e.getClass() != java.lang.NullPointerException.class) { | |
13951 fail(runString, e); | |
13952 return; | |
13953 } | |
13954 } | |
13955 // (-1) == !java.lang.ArrayIndexOutOfBoundsException | |
13956 try { | |
13957 runString = "(-1)"; | |
13958 jtt.except.BC_saload.test(-1); | |
13959 fail(runString); | |
13960 return; | |
13961 } catch (Throwable e) { | |
13962 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13963 fail(runString, e); | |
13964 return; | |
13965 } | |
13966 } | |
13967 // (0) == 0 | |
13968 runString = "(0)"; | |
13969 if ((short) 0 != jtt.except.BC_saload.test(0)) { | |
13970 fail(runString); | |
13971 return; | |
13972 } | |
13973 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
13974 try { | |
13975 runString = "(4)"; | |
13976 jtt.except.BC_saload.test(4); | |
13977 fail(runString); | |
13978 return; | |
13979 } catch (Throwable e) { | |
13980 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
13981 fail(runString, e); | |
13982 return; | |
13983 } | |
13984 } | |
13985 } catch (Throwable t) { | |
13986 fail(runString, t); | |
13987 return; | |
13988 } | |
13989 pass(); | |
13990 } | |
13991 | |
13992 static void jtt_except_BC_sastore() { | |
13993 begin("jtt.except.BC_sastore"); | |
13994 String runString = null; | |
13995 try { | |
13996 // (-2,0) == !java.lang.NullPointerException | |
13997 try { | |
13998 runString = "(-2,0)"; | |
13999 jtt.except.BC_sastore.test(-2, (short) 0); | |
14000 fail(runString); | |
14001 return; | |
14002 } catch (Throwable e) { | |
14003 if (e.getClass() != java.lang.NullPointerException.class) { | |
14004 fail(runString, e); | |
14005 return; | |
14006 } | |
14007 } | |
14008 // (-1,3) == !java.lang.ArrayIndexOutOfBoundsException | |
14009 try { | |
14010 runString = "(-1,3)"; | |
14011 jtt.except.BC_sastore.test(-1, (short) 3); | |
14012 fail(runString); | |
14013 return; | |
14014 } catch (Throwable e) { | |
14015 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
14016 fail(runString, e); | |
14017 return; | |
14018 } | |
14019 } | |
14020 // (0,0) == 0 | |
14021 runString = "(0,0)"; | |
14022 if ((short) 0 != jtt.except.BC_sastore.test(0, (short) 0)) { | |
14023 fail(runString); | |
14024 return; | |
14025 } | |
14026 // (4,0) == !java.lang.ArrayIndexOutOfBoundsException | |
14027 try { | |
14028 runString = "(4,0)"; | |
14029 jtt.except.BC_sastore.test(4, (short) 0); | |
14030 fail(runString); | |
14031 return; | |
14032 } catch (Throwable e) { | |
14033 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
14034 fail(runString, e); | |
14035 return; | |
14036 } | |
14037 } | |
14038 } catch (Throwable t) { | |
14039 fail(runString, t); | |
14040 return; | |
14041 } | |
14042 pass(); | |
14043 } | |
14044 | |
14045 static void jtt_except_Catch_Loop01() { | |
14046 begin("jtt.except.Catch_Loop01"); | |
14047 String runString = null; | |
14048 try { | |
14049 // (4) == -170 | |
14050 runString = "(4)"; | |
14051 if (-170 != jtt.except.Catch_Loop01.test(4)) { | |
14052 fail(runString); | |
14053 return; | |
14054 } | |
14055 // (5) == -150 | |
14056 runString = "(5)"; | |
14057 if (-150 != jtt.except.Catch_Loop01.test(5)) { | |
14058 fail(runString); | |
14059 return; | |
14060 } | |
14061 // (6) == -140 | |
14062 runString = "(6)"; | |
14063 if (-140 != jtt.except.Catch_Loop01.test(6)) { | |
14064 fail(runString); | |
14065 return; | |
14066 } | |
14067 // (7) == -240 | |
14068 runString = "(7)"; | |
14069 if (-240 != jtt.except.Catch_Loop01.test(7)) { | |
14070 fail(runString); | |
14071 return; | |
14072 } | |
14073 // (30) == -700 | |
14074 runString = "(30)"; | |
14075 if (-700 != jtt.except.Catch_Loop01.test(30)) { | |
14076 fail(runString); | |
14077 return; | |
14078 } | |
14079 } catch (Throwable t) { | |
14080 fail(runString, t); | |
14081 return; | |
14082 } | |
14083 pass(); | |
14084 } | |
14085 | |
14086 static void jtt_except_Catch_Loop02() { | |
14087 begin("jtt.except.Catch_Loop02"); | |
14088 String runString = null; | |
14089 try { | |
14090 // (4) == -170 | |
14091 runString = "(4)"; | |
14092 if (-170 != jtt.except.Catch_Loop02.test(4)) { | |
14093 fail(runString); | |
14094 return; | |
14095 } | |
14096 // (5) == -150 | |
14097 runString = "(5)"; | |
14098 if (-150 != jtt.except.Catch_Loop02.test(5)) { | |
14099 fail(runString); | |
14100 return; | |
14101 } | |
14102 // (6) == -140 | |
14103 runString = "(6)"; | |
14104 if (-140 != jtt.except.Catch_Loop02.test(6)) { | |
14105 fail(runString); | |
14106 return; | |
14107 } | |
14108 // (7) == -240 | |
14109 runString = "(7)"; | |
14110 if (-240 != jtt.except.Catch_Loop02.test(7)) { | |
14111 fail(runString); | |
14112 return; | |
14113 } | |
14114 // (30) == -700 | |
14115 runString = "(30)"; | |
14116 if (-700 != jtt.except.Catch_Loop02.test(30)) { | |
14117 fail(runString); | |
14118 return; | |
14119 } | |
14120 } catch (Throwable t) { | |
14121 fail(runString, t); | |
14122 return; | |
14123 } | |
14124 pass(); | |
14125 } | |
14126 | |
14127 static void jtt_except_Catch_NASE_1() { | |
14128 begin("jtt.except.Catch_NASE_1"); | |
14129 String runString = null; | |
14130 try { | |
14131 // (-1) == 100 | |
14132 runString = "(-1)"; | |
14133 if (100 != jtt.except.Catch_NASE_1.test(-1)) { | |
14134 fail(runString); | |
14135 return; | |
14136 } | |
14137 // (-34) == 100 | |
14138 runString = "(-34)"; | |
14139 if (100 != jtt.except.Catch_NASE_1.test(-34)) { | |
14140 fail(runString); | |
14141 return; | |
14142 } | |
14143 } catch (Throwable t) { | |
14144 fail(runString, t); | |
14145 return; | |
14146 } | |
14147 pass(); | |
14148 } | |
14149 | |
14150 static void jtt_except_Catch_NASE_2() { | |
14151 begin("jtt.except.Catch_NASE_2"); | |
14152 String runString = null; | |
14153 try { | |
14154 // (-1) == 100 | |
14155 runString = "(-1)"; | |
14156 if (100 != jtt.except.Catch_NASE_2.test(-1)) { | |
14157 fail(runString); | |
14158 return; | |
14159 } | |
14160 // (-34) == 100 | |
14161 runString = "(-34)"; | |
14162 if (100 != jtt.except.Catch_NASE_2.test(-34)) { | |
14163 fail(runString); | |
14164 return; | |
14165 } | |
14166 } catch (Throwable t) { | |
14167 fail(runString, t); | |
14168 return; | |
14169 } | |
14170 pass(); | |
14171 } | |
14172 | |
14173 static void jtt_except_Catch_NPE_00() { | |
14174 begin("jtt.except.Catch_NPE_00"); | |
14175 String runString = null; | |
14176 try { | |
14177 // (-3) == -1 | |
14178 runString = "(-3)"; | |
14179 if (-1 != jtt.except.Catch_NPE_00.test(-3)) { | |
14180 fail(runString); | |
14181 return; | |
14182 } | |
14183 // (0) == -1 | |
14184 runString = "(0)"; | |
14185 if (-1 != jtt.except.Catch_NPE_00.test(0)) { | |
14186 fail(runString); | |
14187 return; | |
14188 } | |
14189 // (1) == 3 | |
14190 runString = "(1)"; | |
14191 if (3 != jtt.except.Catch_NPE_00.test(1)) { | |
14192 fail(runString); | |
14193 return; | |
14194 } | |
14195 // (2) == 3 | |
14196 runString = "(2)"; | |
14197 if (3 != jtt.except.Catch_NPE_00.test(2)) { | |
14198 fail(runString); | |
14199 return; | |
14200 } | |
14201 } catch (Throwable t) { | |
14202 fail(runString, t); | |
14203 return; | |
14204 } | |
14205 pass(); | |
14206 } | |
14207 | |
14208 static void jtt_except_Catch_NPE_01() { | |
14209 begin("jtt.except.Catch_NPE_01"); | |
14210 String runString = null; | |
14211 try { | |
14212 // (0) == 0 | |
14213 runString = "(0)"; | |
14214 if (0 != jtt.except.Catch_NPE_01.test(0)) { | |
14215 fail(runString); | |
14216 return; | |
14217 } | |
14218 // (1) == 1 | |
14219 runString = "(1)"; | |
14220 if (1 != jtt.except.Catch_NPE_01.test(1)) { | |
14221 fail(runString); | |
14222 return; | |
14223 } | |
14224 // (-2) == -1 | |
14225 runString = "(-2)"; | |
14226 if (-1 != jtt.except.Catch_NPE_01.test(-2)) { | |
14227 fail(runString); | |
14228 return; | |
14229 } | |
14230 } catch (Throwable t) { | |
14231 fail(runString, t); | |
14232 return; | |
14233 } | |
14234 pass(); | |
14235 } | |
14236 | |
14237 static void jtt_except_Catch_NPE_02() { | |
14238 begin("jtt.except.Catch_NPE_02"); | |
14239 String runString = null; | |
14240 try { | |
14241 // (0) == 0 | |
14242 runString = "(0)"; | |
14243 if (0 != jtt.except.Catch_NPE_02.test(0)) { | |
14244 fail(runString); | |
14245 return; | |
14246 } | |
14247 // (1) == 1 | |
14248 runString = "(1)"; | |
14249 if (1 != jtt.except.Catch_NPE_02.test(1)) { | |
14250 fail(runString); | |
14251 return; | |
14252 } | |
14253 // (-2) == -1 | |
14254 runString = "(-2)"; | |
14255 if (-1 != jtt.except.Catch_NPE_02.test(-2)) { | |
14256 fail(runString); | |
14257 return; | |
14258 } | |
14259 } catch (Throwable t) { | |
14260 fail(runString, t); | |
14261 return; | |
14262 } | |
14263 pass(); | |
14264 } | |
14265 | |
14266 static void jtt_except_Catch_NPE_03() { | |
14267 begin("jtt.except.Catch_NPE_03"); | |
14268 String runString = null; | |
14269 try { | |
14270 // (0) == 0 | |
14271 runString = "(0)"; | |
14272 if (0 != jtt.except.Catch_NPE_03.test(0)) { | |
14273 fail(runString); | |
14274 return; | |
14275 } | |
14276 // (1) == 1 | |
14277 runString = "(1)"; | |
14278 if (1 != jtt.except.Catch_NPE_03.test(1)) { | |
14279 fail(runString); | |
14280 return; | |
14281 } | |
14282 // (-2) == -1 | |
14283 runString = "(-2)"; | |
14284 if (-1 != jtt.except.Catch_NPE_03.test(-2)) { | |
14285 fail(runString); | |
14286 return; | |
14287 } | |
14288 } catch (Throwable t) { | |
14289 fail(runString, t); | |
14290 return; | |
14291 } | |
14292 pass(); | |
14293 } | |
14294 | |
14295 static void jtt_except_Catch_NPE_04() { | |
14296 begin("jtt.except.Catch_NPE_04"); | |
14297 String runString = null; | |
14298 try { | |
14299 // (0) == 0 | |
14300 runString = "(0)"; | |
14301 if (0 != jtt.except.Catch_NPE_04.test(0)) { | |
14302 fail(runString); | |
14303 return; | |
14304 } | |
14305 // (1) == 1 | |
14306 runString = "(1)"; | |
14307 if (1 != jtt.except.Catch_NPE_04.test(1)) { | |
14308 fail(runString); | |
14309 return; | |
14310 } | |
14311 // (-2) == -1 | |
14312 runString = "(-2)"; | |
14313 if (-1 != jtt.except.Catch_NPE_04.test(-2)) { | |
14314 fail(runString); | |
14315 return; | |
14316 } | |
14317 } catch (Throwable t) { | |
14318 fail(runString, t); | |
14319 return; | |
14320 } | |
14321 pass(); | |
14322 } | |
14323 | |
14324 static void jtt_except_Catch_NPE_05() { | |
14325 begin("jtt.except.Catch_NPE_05"); | |
14326 String runString = null; | |
14327 try { | |
14328 // (0) == 0 | |
14329 runString = "(0)"; | |
14330 if (0 != jtt.except.Catch_NPE_05.test(0)) { | |
14331 fail(runString); | |
14332 return; | |
14333 } | |
14334 // (1) == 1 | |
14335 runString = "(1)"; | |
14336 if (1 != jtt.except.Catch_NPE_05.test(1)) { | |
14337 fail(runString); | |
14338 return; | |
14339 } | |
14340 // (-2) == -1 | |
14341 runString = "(-2)"; | |
14342 if (-1 != jtt.except.Catch_NPE_05.test(-2)) { | |
14343 fail(runString); | |
14344 return; | |
14345 } | |
14346 } catch (Throwable t) { | |
14347 fail(runString, t); | |
14348 return; | |
14349 } | |
14350 pass(); | |
14351 } | |
14352 | |
14353 static void jtt_except_Catch_NPE_06() { | |
14354 begin("jtt.except.Catch_NPE_06"); | |
14355 String runString = null; | |
14356 try { | |
14357 // ("") == 0 | |
14358 runString = "(\"\")"; | |
14359 if (0 != jtt.except.Catch_NPE_06.test("")) { | |
14360 fail(runString); | |
14361 return; | |
14362 } | |
14363 // (null) == -1 | |
14364 runString = "(null)"; | |
14365 if (-1 != jtt.except.Catch_NPE_06.test(null)) { | |
14366 fail(runString); | |
14367 return; | |
14368 } | |
14369 } catch (Throwable t) { | |
14370 fail(runString, t); | |
14371 return; | |
14372 } | |
14373 pass(); | |
14374 } | |
14375 | |
14376 static void jtt_except_Catch_NPE_07() { | |
14377 begin("jtt.except.Catch_NPE_07"); | |
14378 String runString = null; | |
14379 try { | |
14380 // (0) == 0 | |
14381 runString = "(0)"; | |
14382 if (0 != jtt.except.Catch_NPE_07.test(0)) { | |
14383 fail(runString); | |
14384 return; | |
14385 } | |
14386 // (1) == 1 | |
14387 runString = "(1)"; | |
14388 if (1 != jtt.except.Catch_NPE_07.test(1)) { | |
14389 fail(runString); | |
14390 return; | |
14391 } | |
14392 } catch (Throwable t) { | |
14393 fail(runString, t); | |
14394 return; | |
14395 } | |
14396 pass(); | |
14397 } | |
14398 | |
14399 static void jtt_except_Catch_NPE_08() { | |
14400 begin("jtt.except.Catch_NPE_08"); | |
14401 String runString = null; | |
14402 try { | |
14403 // (0) == 0 | |
14404 runString = "(0)"; | |
14405 if (0 != jtt.except.Catch_NPE_08.test(0)) { | |
14406 fail(runString); | |
14407 return; | |
14408 } | |
14409 // (1) == 1 | |
14410 runString = "(1)"; | |
14411 if (1 != jtt.except.Catch_NPE_08.test(1)) { | |
14412 fail(runString); | |
14413 return; | |
14414 } | |
14415 // (-2) == -2 | |
14416 runString = "(-2)"; | |
14417 if (-2 != jtt.except.Catch_NPE_08.test(-2)) { | |
14418 fail(runString); | |
14419 return; | |
14420 } | |
14421 } catch (Throwable t) { | |
14422 fail(runString, t); | |
14423 return; | |
14424 } | |
14425 pass(); | |
14426 } | |
14427 | |
14428 static void jtt_except_Catch_NPE_09() { | |
14429 begin("jtt.except.Catch_NPE_09"); | |
14430 String runString = null; | |
14431 try { | |
14432 // (0) == 10 | |
14433 runString = "(0)"; | |
14434 if (10 != jtt.except.Catch_NPE_09.test(0)) { | |
14435 fail(runString); | |
14436 return; | |
14437 } | |
14438 // (1) == 11 | |
14439 runString = "(1)"; | |
14440 if (11 != jtt.except.Catch_NPE_09.test(1)) { | |
14441 fail(runString); | |
14442 return; | |
14443 } | |
14444 // (2) == 1 | |
14445 runString = "(2)"; | |
14446 if (1 != jtt.except.Catch_NPE_09.test(2)) { | |
14447 fail(runString); | |
14448 return; | |
14449 } | |
14450 } catch (Throwable t) { | |
14451 fail(runString, t); | |
14452 return; | |
14453 } | |
14454 pass(); | |
14455 } | |
14456 | |
14457 static void jtt_except_Catch_NPE_10() { | |
14458 begin("jtt.except.Catch_NPE_10"); | |
14459 String runString = null; | |
14460 try { | |
14461 // (0) == 10 | |
14462 runString = "(0)"; | |
14463 if (10 != jtt.except.Catch_NPE_10.test(0)) { | |
14464 fail(runString); | |
14465 return; | |
14466 } | |
14467 // (1) == 11 | |
14468 runString = "(1)"; | |
14469 if (11 != jtt.except.Catch_NPE_10.test(1)) { | |
14470 fail(runString); | |
14471 return; | |
14472 } | |
14473 // (2) == 1 | |
14474 runString = "(2)"; | |
14475 if (1 != jtt.except.Catch_NPE_10.test(2)) { | |
14476 fail(runString); | |
14477 return; | |
14478 } | |
14479 } catch (Throwable t) { | |
14480 fail(runString, t); | |
14481 return; | |
14482 } | |
14483 pass(); | |
14484 } | |
14485 | |
14486 static void jtt_except_Catch_NPE_11() { | |
14487 begin("jtt.except.Catch_NPE_11"); | |
14488 String runString = null; | |
14489 try { | |
14490 // (0) == 10 | |
14491 runString = "(0)"; | |
14492 if (10 != jtt.except.Catch_NPE_11.test(0)) { | |
14493 fail(runString); | |
14494 return; | |
14495 } | |
14496 // (1) == 11 | |
14497 runString = "(1)"; | |
14498 if (11 != jtt.except.Catch_NPE_11.test(1)) { | |
14499 fail(runString); | |
14500 return; | |
14501 } | |
14502 // (2) == 1 | |
14503 runString = "(2)"; | |
14504 if (1 != jtt.except.Catch_NPE_11.test(2)) { | |
14505 fail(runString); | |
14506 return; | |
14507 } | |
14508 } catch (Throwable t) { | |
14509 fail(runString, t); | |
14510 return; | |
14511 } | |
14512 pass(); | |
14513 } | |
14514 | |
14515 static void jtt_except_Catch_StackOverflowError_01() { | |
14516 begin("jtt.except.Catch_StackOverflowError_01"); | |
14517 String runString = null; | |
14518 try { | |
14519 // (0) == !java.lang.StackOverflowError | |
14520 try { | |
14521 runString = "(0)"; | |
14522 jtt.except.Catch_StackOverflowError_01.test(0); | |
14523 fail(runString); | |
14524 return; | |
14525 } catch (Throwable e) { | |
14526 if (e.getClass() != java.lang.StackOverflowError.class) { | |
14527 fail(runString, e); | |
14528 return; | |
14529 } | |
14530 } | |
14531 } catch (Throwable t) { | |
14532 fail(runString, t); | |
14533 return; | |
14534 } | |
14535 pass(); | |
14536 } | |
14537 | |
14538 static void jtt_except_Catch_StackOverflowError_02() { | |
14539 begin("jtt.except.Catch_StackOverflowError_02"); | |
14540 String runString = null; | |
14541 try { | |
14542 // (0) == !java.lang.StackOverflowError | |
14543 try { | |
14544 runString = "(0)"; | |
14545 jtt.except.Catch_StackOverflowError_02.test(0); | |
14546 fail(runString); | |
14547 return; | |
14548 } catch (Throwable e) { | |
14549 if (e.getClass() != java.lang.StackOverflowError.class) { | |
14550 fail(runString, e); | |
14551 return; | |
14552 } | |
14553 } | |
14554 } catch (Throwable t) { | |
14555 fail(runString, t); | |
14556 return; | |
14557 } | |
14558 pass(); | |
14559 } | |
14560 | |
14561 static void jtt_except_Catch_StackOverflowError_03() { | |
14562 begin("jtt.except.Catch_StackOverflowError_03"); | |
14563 String runString = null; | |
14564 try { | |
14565 // (0) == 0 | |
14566 runString = "(0)"; | |
14567 if (0 != jtt.except.Catch_StackOverflowError_03.test(0)) { | |
14568 fail(runString); | |
14569 return; | |
14570 } | |
14571 } catch (Throwable t) { | |
14572 fail(runString, t); | |
14573 return; | |
14574 } | |
14575 pass(); | |
14576 } | |
14577 | |
14578 static void jtt_except_Catch_Two01() { | |
14579 begin("jtt.except.Catch_Two01"); | |
14580 String runString = null; | |
14581 try { | |
14582 // (0) == "java.lang.NullPointerException" | |
14583 runString = "(0)"; | |
14584 if (!"java.lang.NullPointerException".equals(jtt.except.Catch_Two01 | |
14585 .test(0))) { | |
14586 fail(runString); | |
14587 return; | |
14588 } | |
14589 // (1) == "java.lang.ArithmeticException" | |
14590 runString = "(1)"; | |
14591 if (!"java.lang.ArithmeticException".equals(jtt.except.Catch_Two01 | |
14592 .test(1))) { | |
14593 fail(runString); | |
14594 return; | |
14595 } | |
14596 // (3) == "none" | |
14597 runString = "(3)"; | |
14598 if (!"none".equals(jtt.except.Catch_Two01.test(3))) { | |
14599 fail(runString); | |
14600 return; | |
14601 } | |
14602 } catch (Throwable t) { | |
14603 fail(runString, t); | |
14604 return; | |
14605 } | |
14606 pass(); | |
14607 } | |
14608 | |
14609 static void jtt_except_Catch_Two02() { | |
14610 begin("jtt.except.Catch_Two02"); | |
14611 String runString = null; | |
14612 try { | |
14613 // (0) == "java.lang.NullPointerException" | |
14614 runString = "(0)"; | |
14615 if (!"java.lang.NullPointerException".equals(jtt.except.Catch_Two02 | |
14616 .test(0))) { | |
14617 fail(runString); | |
14618 return; | |
14619 } | |
14620 // (1) == "java.lang.ArithmeticException" | |
14621 runString = "(1)"; | |
14622 if (!"java.lang.ArithmeticException".equals(jtt.except.Catch_Two02 | |
14623 .test(1))) { | |
14624 fail(runString); | |
14625 return; | |
14626 } | |
14627 // (3) == "none13" | |
14628 runString = "(3)"; | |
14629 if (!"none13".equals(jtt.except.Catch_Two02.test(3))) { | |
14630 fail(runString); | |
14631 return; | |
14632 } | |
14633 } catch (Throwable t) { | |
14634 fail(runString, t); | |
14635 return; | |
14636 } | |
14637 pass(); | |
14638 } | |
14639 | |
14640 static void jtt_except_Catch_Two03() { | |
14641 begin("jtt.except.Catch_Two03"); | |
14642 String runString = null; | |
14643 try { | |
14644 // (0) == "none4" | |
14645 runString = "(0)"; | |
14646 if (!"none4".equals(jtt.except.Catch_Two03.test(0))) { | |
14647 fail(runString); | |
14648 return; | |
14649 } | |
14650 // (1) == "none4" | |
14651 runString = "(1)"; | |
14652 if (!"none4".equals(jtt.except.Catch_Two03.test(1))) { | |
14653 fail(runString); | |
14654 return; | |
14655 } | |
14656 // (2) == "java.lang.NullPointerException3" | |
14657 runString = "(2)"; | |
14658 if (!"java.lang.NullPointerException3" | |
14659 .equals(jtt.except.Catch_Two03.test(2))) { | |
14660 fail(runString); | |
14661 return; | |
14662 } | |
14663 } catch (Throwable t) { | |
14664 fail(runString, t); | |
14665 return; | |
14666 } | |
14667 pass(); | |
14668 } | |
14669 | |
14670 static void jtt_except_Except_Synchronized01() { | |
14671 begin("jtt.except.Except_Synchronized01"); | |
14672 String runString = null; | |
14673 try { | |
14674 // (0) == 0 | |
14675 runString = "(0)"; | |
14676 if (0 != jtt.except.Except_Synchronized01.test(0)) { | |
14677 fail(runString); | |
14678 return; | |
14679 } | |
14680 // (1) == 2 | |
14681 runString = "(1)"; | |
14682 if (2 != jtt.except.Except_Synchronized01.test(1)) { | |
14683 fail(runString); | |
14684 return; | |
14685 } | |
14686 } catch (Throwable t) { | |
14687 fail(runString, t); | |
14688 return; | |
14689 } | |
14690 pass(); | |
14691 } | |
14692 | |
14693 static void jtt_except_Except_Synchronized02() { | |
14694 begin("jtt.except.Except_Synchronized02"); | |
14695 String runString = null; | |
14696 try { | |
14697 // (0) == 0 | |
14698 runString = "(0)"; | |
14699 if (0 != jtt.except.Except_Synchronized02.test(0)) { | |
14700 fail(runString); | |
14701 return; | |
14702 } | |
14703 // (1) == 2 | |
14704 runString = "(1)"; | |
14705 if (2 != jtt.except.Except_Synchronized02.test(1)) { | |
14706 fail(runString); | |
14707 return; | |
14708 } | |
14709 } catch (Throwable t) { | |
14710 fail(runString, t); | |
14711 return; | |
14712 } | |
14713 pass(); | |
14714 } | |
14715 | |
14716 static void jtt_except_Except_Synchronized03() { | |
14717 begin("jtt.except.Except_Synchronized03"); | |
14718 String runString = null; | |
14719 try { | |
14720 // (0) == 0 | |
14721 runString = "(0)"; | |
14722 if (0 != jtt.except.Except_Synchronized03.test(0)) { | |
14723 fail(runString); | |
14724 return; | |
14725 } | |
14726 // (1) == 2 | |
14727 runString = "(1)"; | |
14728 if (2 != jtt.except.Except_Synchronized03.test(1)) { | |
14729 fail(runString); | |
14730 return; | |
14731 } | |
14732 } catch (Throwable t) { | |
14733 fail(runString, t); | |
14734 return; | |
14735 } | |
14736 pass(); | |
14737 } | |
14738 | |
14739 static void jtt_except_Except_Synchronized04() { | |
14740 begin("jtt.except.Except_Synchronized04"); | |
14741 String runString = null; | |
14742 try { | |
14743 // (0) == 0 | |
14744 runString = "(0)"; | |
14745 if (0 != jtt.except.Except_Synchronized04.test(0)) { | |
14746 fail(runString); | |
14747 return; | |
14748 } | |
14749 // (1) == 2 | |
14750 runString = "(1)"; | |
14751 if (2 != jtt.except.Except_Synchronized04.test(1)) { | |
14752 fail(runString); | |
14753 return; | |
14754 } | |
14755 } catch (Throwable t) { | |
14756 fail(runString, t); | |
14757 return; | |
14758 } | |
14759 pass(); | |
14760 } | |
14761 | |
14762 static void jtt_except_Except_Synchronized05() { | |
14763 begin("jtt.except.Except_Synchronized05"); | |
14764 String runString = null; | |
14765 try { | |
14766 // (0) == 0 | |
14767 runString = "(0)"; | |
14768 if (0 != jtt.except.Except_Synchronized05.test(0)) { | |
14769 fail(runString); | |
14770 return; | |
14771 } | |
14772 // (1) == 2 | |
14773 runString = "(1)"; | |
14774 if (2 != jtt.except.Except_Synchronized05.test(1)) { | |
14775 fail(runString); | |
14776 return; | |
14777 } | |
14778 } catch (Throwable t) { | |
14779 fail(runString, t); | |
14780 return; | |
14781 } | |
14782 pass(); | |
14783 } | |
14784 | |
14785 static void jtt_except_Finally01() { | |
14786 begin("jtt.except.Finally01"); | |
14787 String runString = null; | |
14788 try { | |
14789 // (0) == -1 | |
14790 runString = "(0)"; | |
14791 if (-1 != jtt.except.Finally01.test(0)) { | |
14792 fail(runString); | |
14793 return; | |
14794 } | |
14795 // (1) == -1 | |
14796 runString = "(1)"; | |
14797 if (-1 != jtt.except.Finally01.test(1)) { | |
14798 fail(runString); | |
14799 return; | |
14800 } | |
14801 } catch (Throwable t) { | |
14802 fail(runString, t); | |
14803 return; | |
14804 } | |
14805 pass(); | |
14806 } | |
14807 | |
14808 static void jtt_except_Finally02() { | |
14809 begin("jtt.except.Finally02"); | |
14810 String runString = null; | |
14811 try { | |
14812 // (0) == -1 | |
14813 runString = "(0)"; | |
14814 if (-1 != jtt.except.Finally02.test(0)) { | |
14815 fail(runString); | |
14816 return; | |
14817 } | |
14818 // (1) == -1 | |
14819 runString = "(1)"; | |
14820 if (-1 != jtt.except.Finally02.test(1)) { | |
14821 fail(runString); | |
14822 return; | |
14823 } | |
14824 } catch (Throwable t) { | |
14825 fail(runString, t); | |
14826 return; | |
14827 } | |
14828 pass(); | |
14829 } | |
14830 | |
14831 static void jtt_except_StackTrace_AIOOBE_00() { | |
14832 begin("jtt.except.StackTrace_AIOOBE_00"); | |
14833 String runString = null; | |
14834 try { | |
14835 // (0) == 0 | |
14836 runString = "(0)"; | |
14837 if (0 != jtt.except.StackTrace_AIOOBE_00.test(0)) { | |
14838 fail(runString); | |
14839 return; | |
14840 } | |
14841 // (1) == 0 | |
14842 runString = "(1)"; | |
14843 if (0 != jtt.except.StackTrace_AIOOBE_00.test(1)) { | |
14844 fail(runString); | |
14845 return; | |
14846 } | |
14847 // (-2) == -1 | |
14848 runString = "(-2)"; | |
14849 if (-1 != jtt.except.StackTrace_AIOOBE_00.test(-2)) { | |
14850 fail(runString); | |
14851 return; | |
14852 } | |
14853 // (3) == -1 | |
14854 runString = "(3)"; | |
14855 if (-1 != jtt.except.StackTrace_AIOOBE_00.test(3)) { | |
14856 fail(runString); | |
14857 return; | |
14858 } | |
14859 } catch (Throwable t) { | |
14860 fail(runString, t); | |
14861 return; | |
14862 } | |
14863 pass(); | |
14864 } | |
14865 | |
14866 static void jtt_except_StackTrace_CCE_00() { | |
14867 begin("jtt.except.StackTrace_CCE_00"); | |
14868 String runString = null; | |
14869 try { | |
14870 // (0) == 0 | |
14871 runString = "(0)"; | |
14872 if (0 != jtt.except.StackTrace_CCE_00.test(0)) { | |
14873 fail(runString); | |
14874 return; | |
14875 } | |
14876 // (2) == -100 | |
14877 runString = "(2)"; | |
14878 if (-100 != jtt.except.StackTrace_CCE_00.test(2)) { | |
14879 fail(runString); | |
14880 return; | |
14881 } | |
14882 // (3) == -100 | |
14883 runString = "(3)"; | |
14884 if (-100 != jtt.except.StackTrace_CCE_00.test(3)) { | |
14885 fail(runString); | |
14886 return; | |
14887 } | |
14888 // (4) == 4 | |
14889 runString = "(4)"; | |
14890 if (4 != jtt.except.StackTrace_CCE_00.test(4)) { | |
14891 fail(runString); | |
14892 return; | |
14893 } | |
14894 } catch (Throwable t) { | |
14895 fail(runString, t); | |
14896 return; | |
14897 } | |
14898 pass(); | |
14899 } | |
14900 | |
14901 static void jtt_except_StackTrace_NPE_00() { | |
14902 begin("jtt.except.StackTrace_NPE_00"); | |
14903 String runString = null; | |
14904 try { | |
14905 // (-3) == -1 | |
14906 runString = "(-3)"; | |
14907 if (-1 != jtt.except.StackTrace_NPE_00.test(-3)) { | |
14908 fail(runString); | |
14909 return; | |
14910 } | |
14911 // (0) == -1 | |
14912 runString = "(0)"; | |
14913 if (-1 != jtt.except.StackTrace_NPE_00.test(0)) { | |
14914 fail(runString); | |
14915 return; | |
14916 } | |
14917 // (1) == 3 | |
14918 runString = "(1)"; | |
14919 if (3 != jtt.except.StackTrace_NPE_00.test(1)) { | |
14920 fail(runString); | |
14921 return; | |
14922 } | |
14923 // (2) == 3 | |
14924 runString = "(2)"; | |
14925 if (3 != jtt.except.StackTrace_NPE_00.test(2)) { | |
14926 fail(runString); | |
14927 return; | |
14928 } | |
14929 } catch (Throwable t) { | |
14930 fail(runString, t); | |
14931 return; | |
14932 } | |
14933 pass(); | |
14934 } | |
14935 | |
14936 static void jtt_except_StackTrace_NPE_01() { | |
14937 begin("jtt.except.StackTrace_NPE_01"); | |
14938 String runString = null; | |
14939 try { | |
14940 // (0) == 0 | |
14941 runString = "(0)"; | |
14942 if (0 != jtt.except.StackTrace_NPE_01.test(0)) { | |
14943 fail(runString); | |
14944 return; | |
14945 } | |
14946 // (1) == 1 | |
14947 runString = "(1)"; | |
14948 if (1 != jtt.except.StackTrace_NPE_01.test(1)) { | |
14949 fail(runString); | |
14950 return; | |
14951 } | |
14952 // (-2) == -1 | |
14953 runString = "(-2)"; | |
14954 if (-1 != jtt.except.StackTrace_NPE_01.test(-2)) { | |
14955 fail(runString); | |
14956 return; | |
14957 } | |
14958 } catch (Throwable t) { | |
14959 fail(runString, t); | |
14960 return; | |
14961 } | |
14962 pass(); | |
14963 } | |
14964 | |
14965 static void jtt_except_StackTrace_NPE_02() { | |
14966 begin("jtt.except.StackTrace_NPE_02"); | |
14967 String runString = null; | |
14968 try { | |
14969 // (0) == 0 | |
14970 runString = "(0)"; | |
14971 if (0 != jtt.except.StackTrace_NPE_02.test(0)) { | |
14972 fail(runString); | |
14973 return; | |
14974 } | |
14975 // (1) == 0 | |
14976 runString = "(1)"; | |
14977 if (0 != jtt.except.StackTrace_NPE_02.test(1)) { | |
14978 fail(runString); | |
14979 return; | |
14980 } | |
14981 // (-2) == -1 | |
14982 runString = "(-2)"; | |
14983 if (-1 != jtt.except.StackTrace_NPE_02.test(-2)) { | |
14984 fail(runString); | |
14985 return; | |
14986 } | |
14987 // (3) == 0 | |
14988 runString = "(3)"; | |
14989 if (0 != jtt.except.StackTrace_NPE_02.test(3)) { | |
14990 fail(runString); | |
14991 return; | |
14992 } | |
14993 } catch (Throwable t) { | |
14994 fail(runString, t); | |
14995 return; | |
14996 } | |
14997 pass(); | |
14998 } | |
14999 | |
15000 static void jtt_except_StackTrace_NPE_03() { | |
15001 begin("jtt.except.StackTrace_NPE_03"); | |
15002 String runString = null; | |
15003 try { | |
15004 // (0) == 0 | |
15005 runString = "(0)"; | |
15006 if (0 != jtt.except.StackTrace_NPE_03.test(0)) { | |
15007 fail(runString); | |
15008 return; | |
15009 } | |
15010 // (1) == 0 | |
15011 runString = "(1)"; | |
15012 if (0 != jtt.except.StackTrace_NPE_03.test(1)) { | |
15013 fail(runString); | |
15014 return; | |
15015 } | |
15016 // (-2) == -1 | |
15017 runString = "(-2)"; | |
15018 if (-1 != jtt.except.StackTrace_NPE_03.test(-2)) { | |
15019 fail(runString); | |
15020 return; | |
15021 } | |
15022 // (3) == 0 | |
15023 runString = "(3)"; | |
15024 if (0 != jtt.except.StackTrace_NPE_03.test(3)) { | |
15025 fail(runString); | |
15026 return; | |
15027 } | |
15028 } catch (Throwable t) { | |
15029 fail(runString, t); | |
15030 return; | |
15031 } | |
15032 pass(); | |
15033 } | |
15034 | |
15035 static void jtt_except_Throw_InCatch01() { | |
15036 begin("jtt.except.Throw_InCatch01"); | |
15037 String runString = null; | |
15038 try { | |
15039 // (0) == true | |
15040 runString = "(0)"; | |
15041 if (true != jtt.except.Throw_InCatch01.test(0)) { | |
15042 fail(runString); | |
15043 return; | |
15044 } | |
15045 // (1) == !java.lang.Exception | |
15046 try { | |
15047 runString = "(1)"; | |
15048 jtt.except.Throw_InCatch01.test(1); | |
15049 fail(runString); | |
15050 return; | |
15051 } catch (Throwable e) { | |
15052 if (e.getClass() != java.lang.Exception.class) { | |
15053 fail(runString, e); | |
15054 return; | |
15055 } | |
15056 } | |
15057 } catch (Throwable t) { | |
15058 fail(runString, t); | |
15059 return; | |
15060 } | |
15061 pass(); | |
15062 } | |
15063 | |
15064 static void jtt_except_Throw_InCatch02() { | |
15065 begin("jtt.except.Throw_InCatch02"); | |
15066 String runString = null; | |
15067 try { | |
15068 // (0) == true | |
15069 runString = "(0)"; | |
15070 if (true != jtt.except.Throw_InCatch02.test(0)) { | |
15071 fail(runString); | |
15072 return; | |
15073 } | |
15074 // (1) == !java.lang.Exception | |
15075 try { | |
15076 runString = "(1)"; | |
15077 jtt.except.Throw_InCatch02.test(1); | |
15078 fail(runString); | |
15079 return; | |
15080 } catch (Throwable e) { | |
15081 if (e.getClass() != java.lang.Exception.class) { | |
15082 fail(runString, e); | |
15083 return; | |
15084 } | |
15085 } | |
15086 } catch (Throwable t) { | |
15087 fail(runString, t); | |
15088 return; | |
15089 } | |
15090 pass(); | |
15091 } | |
15092 | |
15093 static void jtt_except_Throw_InCatch03() { | |
15094 begin("jtt.except.Throw_InCatch03"); | |
15095 String runString = null; | |
15096 try { | |
15097 // (0) == true | |
15098 runString = "(0)"; | |
15099 if (true != jtt.except.Throw_InCatch03.test(0)) { | |
15100 fail(runString); | |
15101 return; | |
15102 } | |
15103 // (1) == !java.lang.Exception | |
15104 try { | |
15105 runString = "(1)"; | |
15106 jtt.except.Throw_InCatch03.test(1); | |
15107 fail(runString); | |
15108 return; | |
15109 } catch (Throwable e) { | |
15110 if (e.getClass() != java.lang.Exception.class) { | |
15111 fail(runString, e); | |
15112 return; | |
15113 } | |
15114 } | |
15115 } catch (Throwable t) { | |
15116 fail(runString, t); | |
15117 return; | |
15118 } | |
15119 pass(); | |
15120 } | |
15121 | |
15122 static void jtt_except_Throw_NPE_01() { | |
15123 begin("jtt.except.Throw_NPE_01"); | |
15124 String runString = null; | |
15125 try { | |
15126 // (0) == 1 | |
15127 runString = "(0)"; | |
15128 if (1 != jtt.except.Throw_NPE_01.test(0)) { | |
15129 fail(runString); | |
15130 return; | |
15131 } | |
15132 // (1) == 2 | |
15133 runString = "(1)"; | |
15134 if (2 != jtt.except.Throw_NPE_01.test(1)) { | |
15135 fail(runString); | |
15136 return; | |
15137 } | |
15138 // (-1) == !java.lang.NullPointerException | |
15139 try { | |
15140 runString = "(-1)"; | |
15141 jtt.except.Throw_NPE_01.test(-1); | |
15142 fail(runString); | |
15143 return; | |
15144 } catch (Throwable e) { | |
15145 if (e.getClass() != java.lang.NullPointerException.class) { | |
15146 fail(runString, e); | |
15147 return; | |
15148 } | |
15149 } | |
15150 } catch (Throwable t) { | |
15151 fail(runString, t); | |
15152 return; | |
15153 } | |
15154 pass(); | |
15155 } | |
15156 | |
15157 static void jtt_except_Throw_Synchronized01() { | |
15158 begin("jtt.except.Throw_Synchronized01"); | |
15159 String runString = null; | |
15160 try { | |
15161 // (0) == true | |
15162 runString = "(0)"; | |
15163 if (true != jtt.except.Throw_Synchronized01.test(0)) { | |
15164 fail(runString); | |
15165 return; | |
15166 } | |
15167 // (1) == !java.lang.Exception | |
15168 try { | |
15169 runString = "(1)"; | |
15170 jtt.except.Throw_Synchronized01.test(1); | |
15171 fail(runString); | |
15172 return; | |
15173 } catch (Throwable e) { | |
15174 if (e.getClass() != java.lang.Exception.class) { | |
15175 fail(runString, e); | |
15176 return; | |
15177 } | |
15178 } | |
15179 } catch (Throwable t) { | |
15180 fail(runString, t); | |
15181 return; | |
15182 } | |
15183 pass(); | |
15184 } | |
15185 | |
15186 static void jtt_except_Throw_Synchronized02() { | |
15187 begin("jtt.except.Throw_Synchronized02"); | |
15188 String runString = null; | |
15189 try { | |
15190 // (0) == true | |
15191 runString = "(0)"; | |
15192 if (true != jtt.except.Throw_Synchronized02.test(0)) { | |
15193 fail(runString); | |
15194 return; | |
15195 } | |
15196 // (1) == !java.lang.Exception | |
15197 try { | |
15198 runString = "(1)"; | |
15199 jtt.except.Throw_Synchronized02.test(1); | |
15200 fail(runString); | |
15201 return; | |
15202 } catch (Throwable e) { | |
15203 if (e.getClass() != java.lang.Exception.class) { | |
15204 fail(runString, e); | |
15205 return; | |
15206 } | |
15207 } | |
15208 } catch (Throwable t) { | |
15209 fail(runString, t); | |
15210 return; | |
15211 } | |
15212 pass(); | |
15213 } | |
15214 | |
15215 static void jtt_except_Throw_Synchronized03() { | |
15216 begin("jtt.except.Throw_Synchronized03"); | |
15217 String runString = null; | |
15218 try { | |
15219 // (0) == true | |
15220 runString = "(0)"; | |
15221 if (true != jtt.except.Throw_Synchronized03.test(0)) { | |
15222 fail(runString); | |
15223 return; | |
15224 } | |
15225 // (1) == !java.lang.Exception | |
15226 try { | |
15227 runString = "(1)"; | |
15228 jtt.except.Throw_Synchronized03.test(1); | |
15229 fail(runString); | |
15230 return; | |
15231 } catch (Throwable e) { | |
15232 if (e.getClass() != java.lang.Exception.class) { | |
15233 fail(runString, e); | |
15234 return; | |
15235 } | |
15236 } | |
15237 } catch (Throwable t) { | |
15238 fail(runString, t); | |
15239 return; | |
15240 } | |
15241 pass(); | |
15242 } | |
15243 | |
15244 static void jtt_except_Throw_Synchronized04() { | |
15245 begin("jtt.except.Throw_Synchronized04"); | |
15246 String runString = null; | |
15247 try { | |
15248 // (0) == true | |
15249 runString = "(0)"; | |
15250 if (true != jtt.except.Throw_Synchronized04.test(0)) { | |
15251 fail(runString); | |
15252 return; | |
15253 } | |
15254 // (1) == !java.lang.Exception | |
15255 try { | |
15256 runString = "(1)"; | |
15257 jtt.except.Throw_Synchronized04.test(1); | |
15258 fail(runString); | |
15259 return; | |
15260 } catch (Throwable e) { | |
15261 if (e.getClass() != java.lang.Exception.class) { | |
15262 fail(runString, e); | |
15263 return; | |
15264 } | |
15265 } | |
15266 } catch (Throwable t) { | |
15267 fail(runString, t); | |
15268 return; | |
15269 } | |
15270 pass(); | |
15271 } | |
15272 | |
15273 static void jtt_except_Throw_Synchronized05() { | |
15274 begin("jtt.except.Throw_Synchronized05"); | |
15275 String runString = null; | |
15276 try { | |
15277 // (0) == true | |
15278 runString = "(0)"; | |
15279 if (true != jtt.except.Throw_Synchronized05.test(0)) { | |
15280 fail(runString); | |
15281 return; | |
15282 } | |
15283 // (1) == !java.lang.Exception | |
15284 try { | |
15285 runString = "(1)"; | |
15286 jtt.except.Throw_Synchronized05.test(1); | |
15287 fail(runString); | |
15288 return; | |
15289 } catch (Throwable e) { | |
15290 if (e.getClass() != java.lang.Exception.class) { | |
15291 fail(runString, e); | |
15292 return; | |
15293 } | |
15294 } | |
15295 } catch (Throwable t) { | |
15296 fail(runString, t); | |
15297 return; | |
15298 } | |
15299 pass(); | |
15300 } | |
15301 | |
15302 static void jtt_lang_Boxed_TYPE_01() { | |
15303 begin("jtt.lang.Boxed_TYPE_01"); | |
15304 String runString = null; | |
15305 try { | |
15306 // (0) == "boolean" | |
15307 runString = "(0)"; | |
15308 if (!"boolean".equals(jtt.lang.Boxed_TYPE_01.test(0))) { | |
15309 fail(runString); | |
15310 return; | |
15311 } | |
15312 // (1) == "byte" | |
15313 runString = "(1)"; | |
15314 if (!"byte".equals(jtt.lang.Boxed_TYPE_01.test(1))) { | |
15315 fail(runString); | |
15316 return; | |
15317 } | |
15318 // (2) == "char" | |
15319 runString = "(2)"; | |
15320 if (!"char".equals(jtt.lang.Boxed_TYPE_01.test(2))) { | |
15321 fail(runString); | |
15322 return; | |
15323 } | |
15324 // (3) == "double" | |
15325 runString = "(3)"; | |
15326 if (!"double".equals(jtt.lang.Boxed_TYPE_01.test(3))) { | |
15327 fail(runString); | |
15328 return; | |
15329 } | |
15330 // (4) == "float" | |
15331 runString = "(4)"; | |
15332 if (!"float".equals(jtt.lang.Boxed_TYPE_01.test(4))) { | |
15333 fail(runString); | |
15334 return; | |
15335 } | |
15336 // (5) == "int" | |
15337 runString = "(5)"; | |
15338 if (!"int".equals(jtt.lang.Boxed_TYPE_01.test(5))) { | |
15339 fail(runString); | |
15340 return; | |
15341 } | |
15342 // (6) == "long" | |
15343 runString = "(6)"; | |
15344 if (!"long".equals(jtt.lang.Boxed_TYPE_01.test(6))) { | |
15345 fail(runString); | |
15346 return; | |
15347 } | |
15348 // (7) == "short" | |
15349 runString = "(7)"; | |
15350 if (!"short".equals(jtt.lang.Boxed_TYPE_01.test(7))) { | |
15351 fail(runString); | |
15352 return; | |
15353 } | |
15354 // (8) == "void" | |
15355 runString = "(8)"; | |
15356 if (!"void".equals(jtt.lang.Boxed_TYPE_01.test(8))) { | |
15357 fail(runString); | |
15358 return; | |
15359 } | |
15360 } catch (Throwable t) { | |
15361 fail(runString, t); | |
15362 return; | |
15363 } | |
15364 pass(); | |
15365 } | |
15366 | |
15367 static void jtt_lang_Bridge_method01() { | |
15368 begin("jtt.lang.Bridge_method01"); | |
15369 String runString = null; | |
15370 try { | |
15371 // (0) == 1 | |
15372 runString = "(0)"; | |
15373 if (1 != jtt.lang.Bridge_method01.test(0)) { | |
15374 fail(runString); | |
15375 return; | |
15376 } | |
15377 // (1) == 1 | |
15378 runString = "(1)"; | |
15379 if (1 != jtt.lang.Bridge_method01.test(1)) { | |
15380 fail(runString); | |
15381 return; | |
15382 } | |
15383 } catch (Throwable t) { | |
15384 fail(runString, t); | |
15385 return; | |
15386 } | |
15387 pass(); | |
15388 } | |
15389 | |
15390 static void jtt_lang_ClassLoader_loadClass01() { | |
15391 begin("jtt.lang.ClassLoader_loadClass01"); | |
15392 String runString = null; | |
15393 try { | |
15394 // (0) == "class java.lang.String" | |
15395 runString = "(0)"; | |
15396 if (!"class java.lang.String" | |
15397 .equals(jtt.lang.ClassLoader_loadClass01.test(0))) { | |
15398 fail(runString); | |
15399 return; | |
15400 } | |
15401 // (1) == !java.lang.ClassNotFoundException | |
15402 try { | |
15403 runString = "(1)"; | |
15404 jtt.lang.ClassLoader_loadClass01.test(1); | |
15405 fail(runString); | |
15406 return; | |
15407 } catch (Throwable e) { | |
15408 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15409 fail(runString, e); | |
15410 return; | |
15411 } | |
15412 } | |
15413 // (2) == !java.lang.ClassNotFoundException | |
15414 try { | |
15415 runString = "(2)"; | |
15416 jtt.lang.ClassLoader_loadClass01.test(2); | |
15417 fail(runString); | |
15418 return; | |
15419 } catch (Throwable e) { | |
15420 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15421 fail(runString, e); | |
15422 return; | |
15423 } | |
15424 } | |
15425 } catch (Throwable t) { | |
15426 fail(runString, t); | |
15427 return; | |
15428 } | |
15429 pass(); | |
15430 } | |
15431 | |
15432 static void jtt_lang_Class_Literal01() { | |
15433 begin("jtt.lang.Class_Literal01"); | |
15434 String runString = null; | |
15435 try { | |
15436 // (0) == "class java.lang.Object" | |
15437 runString = "(0)"; | |
15438 if (!"class java.lang.Object".equals(jtt.lang.Class_Literal01 | |
15439 .test(0))) { | |
15440 fail(runString); | |
15441 return; | |
15442 } | |
15443 // (1) == "class java.lang.String" | |
15444 runString = "(1)"; | |
15445 if (!"class java.lang.String".equals(jtt.lang.Class_Literal01 | |
15446 .test(1))) { | |
15447 fail(runString); | |
15448 return; | |
15449 } | |
15450 // (2) == "class java.lang.Class" | |
15451 runString = "(2)"; | |
15452 if (!"class java.lang.Class".equals(jtt.lang.Class_Literal01 | |
15453 .test(2))) { | |
15454 fail(runString); | |
15455 return; | |
15456 } | |
15457 // (3) == "class jtt.lang.Class_Literal01" | |
15458 runString = "(3)"; | |
15459 if (!"class jtt.lang.Class_Literal01" | |
15460 .equals(jtt.lang.Class_Literal01.test(3))) { | |
15461 fail(runString); | |
15462 return; | |
15463 } | |
15464 // (4) == null | |
15465 runString = "(4)"; | |
15466 if (null != jtt.lang.Class_Literal01.test(4)) { | |
15467 fail(runString); | |
15468 return; | |
15469 } | |
15470 } catch (Throwable t) { | |
15471 fail(runString, t); | |
15472 return; | |
15473 } | |
15474 pass(); | |
15475 } | |
15476 | |
15477 static void jtt_lang_Class_asSubclass01() { | |
15478 begin("jtt.lang.Class_asSubclass01"); | |
15479 String runString = null; | |
15480 try { | |
15481 // (0) == !java.lang.ClassCastException | |
15482 try { | |
15483 runString = "(0)"; | |
15484 jtt.lang.Class_asSubclass01.test(0); | |
15485 fail(runString); | |
15486 return; | |
15487 } catch (Throwable e) { | |
15488 if (e.getClass() != java.lang.ClassCastException.class) { | |
15489 fail(runString, e); | |
15490 return; | |
15491 } | |
15492 } | |
15493 // (1) == 1 | |
15494 runString = "(1)"; | |
15495 if (1 != jtt.lang.Class_asSubclass01.test(1)) { | |
15496 fail(runString); | |
15497 return; | |
15498 } | |
15499 // (2) == !java.lang.ClassCastException | |
15500 try { | |
15501 runString = "(2)"; | |
15502 jtt.lang.Class_asSubclass01.test(2); | |
15503 fail(runString); | |
15504 return; | |
15505 } catch (Throwable e) { | |
15506 if (e.getClass() != java.lang.ClassCastException.class) { | |
15507 fail(runString, e); | |
15508 return; | |
15509 } | |
15510 } | |
15511 // (3) == 3 | |
15512 runString = "(3)"; | |
15513 if (3 != jtt.lang.Class_asSubclass01.test(3)) { | |
15514 fail(runString); | |
15515 return; | |
15516 } | |
15517 // (4) == 4 | |
15518 runString = "(4)"; | |
15519 if (4 != jtt.lang.Class_asSubclass01.test(4)) { | |
15520 fail(runString); | |
15521 return; | |
15522 } | |
15523 } catch (Throwable t) { | |
15524 fail(runString, t); | |
15525 return; | |
15526 } | |
15527 pass(); | |
15528 } | |
15529 | |
15530 static void jtt_lang_Class_cast01() { | |
15531 begin("jtt.lang.Class_cast01"); | |
15532 String runString = null; | |
15533 try { | |
15534 // (1) == !java.lang.ClassCastException | |
15535 try { | |
15536 runString = "(1)"; | |
15537 jtt.lang.Class_cast01.test(1); | |
15538 fail(runString); | |
15539 return; | |
15540 } catch (Throwable e) { | |
15541 if (e.getClass() != java.lang.ClassCastException.class) { | |
15542 fail(runString, e); | |
15543 return; | |
15544 } | |
15545 } | |
15546 // (0) == 0 | |
15547 runString = "(0)"; | |
15548 if (0 != jtt.lang.Class_cast01.test(0)) { | |
15549 fail(runString); | |
15550 return; | |
15551 } | |
15552 // (3) == !java.lang.ClassCastException | |
15553 try { | |
15554 runString = "(3)"; | |
15555 jtt.lang.Class_cast01.test(3); | |
15556 fail(runString); | |
15557 return; | |
15558 } catch (Throwable e) { | |
15559 if (e.getClass() != java.lang.ClassCastException.class) { | |
15560 fail(runString, e); | |
15561 return; | |
15562 } | |
15563 } | |
15564 // (2) == 2 | |
15565 runString = "(2)"; | |
15566 if (2 != jtt.lang.Class_cast01.test(2)) { | |
15567 fail(runString); | |
15568 return; | |
15569 } | |
15570 // (4) == 4 | |
15571 runString = "(4)"; | |
15572 if (4 != jtt.lang.Class_cast01.test(4)) { | |
15573 fail(runString); | |
15574 return; | |
15575 } | |
15576 } catch (Throwable t) { | |
15577 fail(runString, t); | |
15578 return; | |
15579 } | |
15580 pass(); | |
15581 } | |
15582 | |
15583 static void jtt_lang_Class_cast02() { | |
15584 begin("jtt.lang.Class_cast02"); | |
15585 String runString = null; | |
15586 try { | |
15587 // (0) == -1 | |
15588 runString = "(0)"; | |
15589 if (-1 != jtt.lang.Class_cast02.test(0)) { | |
15590 fail(runString); | |
15591 return; | |
15592 } | |
15593 // (1) == -1 | |
15594 runString = "(1)"; | |
15595 if (-1 != jtt.lang.Class_cast02.test(1)) { | |
15596 fail(runString); | |
15597 return; | |
15598 } | |
15599 // (2) == -1 | |
15600 runString = "(2)"; | |
15601 if (-1 != jtt.lang.Class_cast02.test(2)) { | |
15602 fail(runString); | |
15603 return; | |
15604 } | |
15605 // (3) == -1 | |
15606 runString = "(3)"; | |
15607 if (-1 != jtt.lang.Class_cast02.test(3)) { | |
15608 fail(runString); | |
15609 return; | |
15610 } | |
15611 // (4) == 4 | |
15612 runString = "(4)"; | |
15613 if (4 != jtt.lang.Class_cast02.test(4)) { | |
15614 fail(runString); | |
15615 return; | |
15616 } | |
15617 } catch (Throwable t) { | |
15618 fail(runString, t); | |
15619 return; | |
15620 } | |
15621 pass(); | |
15622 } | |
15623 | |
15624 static void jtt_lang_Class_forName01() { | |
15625 begin("jtt.lang.Class_forName01"); | |
15626 String runString = null; | |
15627 try { | |
15628 // (0) == "class java.lang.Object" | |
15629 runString = "(0)"; | |
15630 if (!"class java.lang.Object".equals(jtt.lang.Class_forName01 | |
15631 .test(0))) { | |
15632 fail(runString); | |
15633 return; | |
15634 } | |
15635 // (1) == "class java.lang.String" | |
15636 runString = "(1)"; | |
15637 if (!"class java.lang.String".equals(jtt.lang.Class_forName01 | |
15638 .test(1))) { | |
15639 fail(runString); | |
15640 return; | |
15641 } | |
15642 // (2) == "class jtt.lang.Class_forName01" | |
15643 runString = "(2)"; | |
15644 if (!"class jtt.lang.Class_forName01" | |
15645 .equals(jtt.lang.Class_forName01.test(2))) { | |
15646 fail(runString); | |
15647 return; | |
15648 } | |
15649 // (3) == !java.lang.ClassNotFoundException | |
15650 try { | |
15651 runString = "(3)"; | |
15652 jtt.lang.Class_forName01.test(3); | |
15653 fail(runString); | |
15654 return; | |
15655 } catch (Throwable e) { | |
15656 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15657 fail(runString, e); | |
15658 return; | |
15659 } | |
15660 } | |
15661 } catch (Throwable t) { | |
15662 fail(runString, t); | |
15663 return; | |
15664 } | |
15665 pass(); | |
15666 } | |
15667 | |
15668 static void jtt_lang_Class_forName02() { | |
15669 begin("jtt.lang.Class_forName02"); | |
15670 String runString = null; | |
15671 try { | |
15672 // (0) == "class java.lang.Object" | |
15673 runString = "(0)"; | |
15674 if (!"class java.lang.Object".equals(jtt.lang.Class_forName02 | |
15675 .test(0))) { | |
15676 fail(runString); | |
15677 return; | |
15678 } | |
15679 // (1) == "class java.lang.String" | |
15680 runString = "(1)"; | |
15681 if (!"class java.lang.String".equals(jtt.lang.Class_forName02 | |
15682 .test(1))) { | |
15683 fail(runString); | |
15684 return; | |
15685 } | |
15686 // (2) == "class jtt.lang.Class_forName02" | |
15687 runString = "(2)"; | |
15688 if (!"class jtt.lang.Class_forName02" | |
15689 .equals(jtt.lang.Class_forName02.test(2))) { | |
15690 fail(runString); | |
15691 return; | |
15692 } | |
15693 // (3) == !java.lang.ClassNotFoundException | |
15694 try { | |
15695 runString = "(3)"; | |
15696 jtt.lang.Class_forName02.test(3); | |
15697 fail(runString); | |
15698 return; | |
15699 } catch (Throwable e) { | |
15700 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15701 fail(runString, e); | |
15702 return; | |
15703 } | |
15704 } | |
15705 } catch (Throwable t) { | |
15706 fail(runString, t); | |
15707 return; | |
15708 } | |
15709 pass(); | |
15710 } | |
15711 | |
15712 static void jtt_lang_Class_forName03() { | |
15713 begin("jtt.lang.Class_forName03"); | |
15714 String runString = null; | |
15715 try { | |
15716 // (0) == !java.lang.ClassNotFoundException | |
15717 try { | |
15718 runString = "(0)"; | |
15719 jtt.lang.Class_forName03.test(0); | |
15720 fail(runString); | |
15721 return; | |
15722 } catch (Throwable e) { | |
15723 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15724 fail(runString, e); | |
15725 return; | |
15726 } | |
15727 } | |
15728 // (1) == "class [Ljava.lang.String;" | |
15729 runString = "(1)"; | |
15730 if (!"class [Ljava.lang.String;".equals(jtt.lang.Class_forName03 | |
15731 .test(1))) { | |
15732 fail(runString); | |
15733 return; | |
15734 } | |
15735 // (2) == !java.lang.ClassNotFoundException | |
15736 try { | |
15737 runString = "(2)"; | |
15738 jtt.lang.Class_forName03.test(2); | |
15739 fail(runString); | |
15740 return; | |
15741 } catch (Throwable e) { | |
15742 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15743 fail(runString, e); | |
15744 return; | |
15745 } | |
15746 } | |
15747 // (3) == "class [I" | |
15748 runString = "(3)"; | |
15749 if (!"class [I".equals(jtt.lang.Class_forName03.test(3))) { | |
15750 fail(runString); | |
15751 return; | |
15752 } | |
15753 // (4) == !java.lang.ClassNotFoundException | |
15754 try { | |
15755 runString = "(4)"; | |
15756 jtt.lang.Class_forName03.test(4); | |
15757 fail(runString); | |
15758 return; | |
15759 } catch (Throwable e) { | |
15760 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15761 fail(runString, e); | |
15762 return; | |
15763 } | |
15764 } | |
15765 // (5) == null | |
15766 runString = "(5)"; | |
15767 if (null != jtt.lang.Class_forName03.test(5)) { | |
15768 fail(runString); | |
15769 return; | |
15770 } | |
15771 } catch (Throwable t) { | |
15772 fail(runString, t); | |
15773 return; | |
15774 } | |
15775 pass(); | |
15776 } | |
15777 | |
15778 static void jtt_lang_Class_forName04() { | |
15779 begin("jtt.lang.Class_forName04"); | |
15780 String runString = null; | |
15781 try { | |
15782 // (0) == !java.lang.ClassNotFoundException | |
15783 try { | |
15784 runString = "(0)"; | |
15785 jtt.lang.Class_forName04.test(0); | |
15786 fail(runString); | |
15787 return; | |
15788 } catch (Throwable e) { | |
15789 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15790 fail(runString, e); | |
15791 return; | |
15792 } | |
15793 } | |
15794 // (1) == "class [Ljava.lang.String;" | |
15795 runString = "(1)"; | |
15796 if (!"class [Ljava.lang.String;".equals(jtt.lang.Class_forName04 | |
15797 .test(1))) { | |
15798 fail(runString); | |
15799 return; | |
15800 } | |
15801 // (2) == !java.lang.ClassNotFoundException | |
15802 try { | |
15803 runString = "(2)"; | |
15804 jtt.lang.Class_forName04.test(2); | |
15805 fail(runString); | |
15806 return; | |
15807 } catch (Throwable e) { | |
15808 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15809 fail(runString, e); | |
15810 return; | |
15811 } | |
15812 } | |
15813 // (3) == "class [I" | |
15814 runString = "(3)"; | |
15815 if (!"class [I".equals(jtt.lang.Class_forName04.test(3))) { | |
15816 fail(runString); | |
15817 return; | |
15818 } | |
15819 // (4) == !java.lang.ClassNotFoundException | |
15820 try { | |
15821 runString = "(4)"; | |
15822 jtt.lang.Class_forName04.test(4); | |
15823 fail(runString); | |
15824 return; | |
15825 } catch (Throwable e) { | |
15826 if (e.getClass() != java.lang.ClassNotFoundException.class) { | |
15827 fail(runString, e); | |
15828 return; | |
15829 } | |
15830 } | |
15831 // (5) == null | |
15832 runString = "(5)"; | |
15833 if (null != jtt.lang.Class_forName04.test(5)) { | |
15834 fail(runString); | |
15835 return; | |
15836 } | |
15837 } catch (Throwable t) { | |
15838 fail(runString, t); | |
15839 return; | |
15840 } | |
15841 pass(); | |
15842 } | |
15843 | |
15844 static void jtt_lang_Class_forName05() { | |
15845 begin("jtt.lang.Class_forName05"); | |
15846 String runString = null; | |
15847 try { | |
15848 // (0) == "class java.lang.String" | |
15849 runString = "(0)"; | |
15850 if (!"class java.lang.String".equals(jtt.lang.Class_forName05 | |
15851 .test(0))) { | |
15852 fail(runString); | |
15853 return; | |
15854 } | |
15855 // (1) == "class [Ljava.lang.String;" | |
15856 runString = "(1)"; | |
15857 if (!"class [Ljava.lang.String;".equals(jtt.lang.Class_forName05 | |
15858 .test(1))) { | |
15859 fail(runString); | |
15860 return; | |
15861 } | |
15862 // (5) == null | |
15863 runString = "(5)"; | |
15864 if (null != jtt.lang.Class_forName05.test(5)) { | |
15865 fail(runString); | |
15866 return; | |
15867 } | |
15868 } catch (Throwable t) { | |
15869 fail(runString, t); | |
15870 return; | |
15871 } | |
15872 pass(); | |
15873 } | |
15874 | |
15875 static void jtt_lang_Class_getComponentType01() { | |
15876 begin("jtt.lang.Class_getComponentType01"); | |
15877 String runString = null; | |
15878 try { | |
15879 // (0) == null | |
15880 runString = "(0)"; | |
15881 if (null != jtt.lang.Class_getComponentType01.test(0)) { | |
15882 fail(runString); | |
15883 return; | |
15884 } | |
15885 // (1) == "int" | |
15886 runString = "(1)"; | |
15887 if (!"int".equals(jtt.lang.Class_getComponentType01.test(1))) { | |
15888 fail(runString); | |
15889 return; | |
15890 } | |
15891 // (2) == null | |
15892 runString = "(2)"; | |
15893 if (null != jtt.lang.Class_getComponentType01.test(2)) { | |
15894 fail(runString); | |
15895 return; | |
15896 } | |
15897 // (3) == "java.lang.Object" | |
15898 runString = "(3)"; | |
15899 if (!"java.lang.Object".equals(jtt.lang.Class_getComponentType01 | |
15900 .test(3))) { | |
15901 fail(runString); | |
15902 return; | |
15903 } | |
15904 // (4) == null | |
15905 runString = "(4)"; | |
15906 if (null != jtt.lang.Class_getComponentType01.test(4)) { | |
15907 fail(runString); | |
15908 return; | |
15909 } | |
15910 // (5) == null | |
15911 runString = "(5)"; | |
15912 if (null != jtt.lang.Class_getComponentType01.test(5)) { | |
15913 fail(runString); | |
15914 return; | |
15915 } | |
15916 // (6) == "[Ljava.lang.Object;" | |
15917 runString = "(6)"; | |
15918 if (!"[Ljava.lang.Object;".equals(jtt.lang.Class_getComponentType01 | |
15919 .test(6))) { | |
15920 fail(runString); | |
15921 return; | |
15922 } | |
15923 // (7) == null | |
15924 runString = "(7)"; | |
15925 if (null != jtt.lang.Class_getComponentType01.test(7)) { | |
15926 fail(runString); | |
15927 return; | |
15928 } | |
15929 // (8) == null | |
15930 runString = "(8)"; | |
15931 if (null != jtt.lang.Class_getComponentType01.test(8)) { | |
15932 fail(runString); | |
15933 return; | |
15934 } | |
15935 } catch (Throwable t) { | |
15936 fail(runString, t); | |
15937 return; | |
15938 } | |
15939 pass(); | |
15940 } | |
15941 | |
15942 static void jtt_lang_Class_getInterfaces01() { | |
15943 begin("jtt.lang.Class_getInterfaces01"); | |
15944 String runString = null; | |
15945 try { | |
15946 // (0) == "" | |
15947 runString = "(0)"; | |
15948 if (!"".equals(jtt.lang.Class_getInterfaces01.test(0))) { | |
15949 fail(runString); | |
15950 return; | |
15951 } | |
15952 // (1) == "jtt.lang.Class_getInterfaces01$I1" | |
15953 runString = "(1)"; | |
15954 if (!"jtt.lang.Class_getInterfaces01$I1" | |
15955 .equals(jtt.lang.Class_getInterfaces01.test(1))) { | |
15956 fail(runString); | |
15957 return; | |
15958 } | |
15959 // (2) == "jtt.lang.Class_getInterfaces01$I1" | |
15960 runString = "(2)"; | |
15961 if (!"jtt.lang.Class_getInterfaces01$I1" | |
15962 .equals(jtt.lang.Class_getInterfaces01.test(2))) { | |
15963 fail(runString); | |
15964 return; | |
15965 } | |
15966 // (3) == "jtt.lang.Class_getInterfaces01$I2" | |
15967 runString = "(3)"; | |
15968 if (!"jtt.lang.Class_getInterfaces01$I2" | |
15969 .equals(jtt.lang.Class_getInterfaces01.test(3))) { | |
15970 fail(runString); | |
15971 return; | |
15972 } | |
15973 // (4) == | |
15974 // "jtt.lang.Class_getInterfaces01$I1 jtt.lang.Class_getInterfaces01$I2" | |
15975 runString = "(4)"; | |
15976 if (!"jtt.lang.Class_getInterfaces01$I1 jtt.lang.Class_getInterfaces01$I2" | |
15977 .equals(jtt.lang.Class_getInterfaces01.test(4))) { | |
15978 fail(runString); | |
15979 return; | |
15980 } | |
15981 } catch (Throwable t) { | |
15982 fail(runString, t); | |
15983 return; | |
15984 } | |
15985 pass(); | |
15986 } | |
15987 | |
15988 static void jtt_lang_Class_getName01() { | |
15989 begin("jtt.lang.Class_getName01"); | |
15990 String runString = null; | |
15991 try { | |
15992 // (0) == "java.lang.Object" | |
15993 runString = "(0)"; | |
15994 if (!"java.lang.Object".equals(jtt.lang.Class_getName01.test(0))) { | |
15995 fail(runString); | |
15996 return; | |
15997 } | |
15998 // (1) == "java.lang.Class" | |
15999 runString = "(1)"; | |
16000 if (!"java.lang.Class".equals(jtt.lang.Class_getName01.test(1))) { | |
16001 fail(runString); | |
16002 return; | |
16003 } | |
16004 // (2) == "jtt.lang.Class_getName01" | |
16005 runString = "(2)"; | |
16006 if (!"jtt.lang.Class_getName01".equals(jtt.lang.Class_getName01 | |
16007 .test(2))) { | |
16008 fail(runString); | |
16009 return; | |
16010 } | |
16011 // (3) == "true" | |
16012 runString = "(3)"; | |
16013 if (!"true".equals(jtt.lang.Class_getName01.test(3))) { | |
16014 fail(runString); | |
16015 return; | |
16016 } | |
16017 // (4) == null | |
16018 runString = "(4)"; | |
16019 if (null != jtt.lang.Class_getName01.test(4)) { | |
16020 fail(runString); | |
16021 return; | |
16022 } | |
16023 } catch (Throwable t) { | |
16024 fail(runString, t); | |
16025 return; | |
16026 } | |
16027 pass(); | |
16028 } | |
16029 | |
16030 static void jtt_lang_Class_getName02() { | |
16031 begin("jtt.lang.Class_getName02"); | |
16032 String runString = null; | |
16033 try { | |
16034 // (0) == "int" | |
16035 runString = "(0)"; | |
16036 if (!"int".equals(jtt.lang.Class_getName02.test(0))) { | |
16037 fail(runString); | |
16038 return; | |
16039 } | |
16040 // (1) == "[I" | |
16041 runString = "(1)"; | |
16042 if (!"[I".equals(jtt.lang.Class_getName02.test(1))) { | |
16043 fail(runString); | |
16044 return; | |
16045 } | |
16046 // (2) == "[[Ljava.lang.Object;" | |
16047 runString = "(2)"; | |
16048 if (!"[[Ljava.lang.Object;" | |
16049 .equals(jtt.lang.Class_getName02.test(2))) { | |
16050 fail(runString); | |
16051 return; | |
16052 } | |
16053 // (3) == null | |
16054 runString = "(3)"; | |
16055 if (null != jtt.lang.Class_getName02.test(3)) { | |
16056 fail(runString); | |
16057 return; | |
16058 } | |
16059 } catch (Throwable t) { | |
16060 fail(runString, t); | |
16061 return; | |
16062 } | |
16063 pass(); | |
16064 } | |
16065 | |
16066 static void jtt_lang_Class_getSimpleName01() { | |
16067 begin("jtt.lang.Class_getSimpleName01"); | |
16068 String runString = null; | |
16069 try { | |
16070 // (0) == "Object" | |
16071 runString = "(0)"; | |
16072 if (!"Object".equals(jtt.lang.Class_getSimpleName01.test(0))) { | |
16073 fail(runString); | |
16074 return; | |
16075 } | |
16076 // (1) == "Class" | |
16077 runString = "(1)"; | |
16078 if (!"Class".equals(jtt.lang.Class_getSimpleName01.test(1))) { | |
16079 fail(runString); | |
16080 return; | |
16081 } | |
16082 // (2) == "Class_getSimpleName01" | |
16083 runString = "(2)"; | |
16084 if (!"Class_getSimpleName01".equals(jtt.lang.Class_getSimpleName01 | |
16085 .test(2))) { | |
16086 fail(runString); | |
16087 return; | |
16088 } | |
16089 // (3) == null | |
16090 runString = "(3)"; | |
16091 if (null != jtt.lang.Class_getSimpleName01.test(3)) { | |
16092 fail(runString); | |
16093 return; | |
16094 } | |
16095 } catch (Throwable t) { | |
16096 fail(runString, t); | |
16097 return; | |
16098 } | |
16099 pass(); | |
16100 } | |
16101 | |
16102 static void jtt_lang_Class_getSimpleName02() { | |
16103 begin("jtt.lang.Class_getSimpleName02"); | |
16104 String runString = null; | |
16105 try { | |
16106 // (0) == "int" | |
16107 runString = "(0)"; | |
16108 if (!"int".equals(jtt.lang.Class_getSimpleName02.test(0))) { | |
16109 fail(runString); | |
16110 return; | |
16111 } | |
16112 // (1) == "int[]" | |
16113 runString = "(1)"; | |
16114 if (!"int[]".equals(jtt.lang.Class_getSimpleName02.test(1))) { | |
16115 fail(runString); | |
16116 return; | |
16117 } | |
16118 // (2) == "Object[][]" | |
16119 runString = "(2)"; | |
16120 if (!"Object[][]".equals(jtt.lang.Class_getSimpleName02.test(2))) { | |
16121 fail(runString); | |
16122 return; | |
16123 } | |
16124 // (3) == null | |
16125 runString = "(3)"; | |
16126 if (null != jtt.lang.Class_getSimpleName02.test(3)) { | |
16127 fail(runString); | |
16128 return; | |
16129 } | |
16130 } catch (Throwable t) { | |
16131 fail(runString, t); | |
16132 return; | |
16133 } | |
16134 pass(); | |
16135 } | |
16136 | |
16137 static void jtt_lang_Class_getSuperClass01() { | |
16138 begin("jtt.lang.Class_getSuperClass01"); | |
16139 String runString = null; | |
16140 try { | |
16141 // (0) == null | |
16142 runString = "(0)"; | |
16143 if (null != jtt.lang.Class_getSuperClass01.test(0)) { | |
16144 fail(runString); | |
16145 return; | |
16146 } | |
16147 // (1) == null | |
16148 runString = "(1)"; | |
16149 if (null != jtt.lang.Class_getSuperClass01.test(1)) { | |
16150 fail(runString); | |
16151 return; | |
16152 } | |
16153 // (2) == "java.lang.Object" | |
16154 runString = "(2)"; | |
16155 if (!"java.lang.Object".equals(jtt.lang.Class_getSuperClass01 | |
16156 .test(2))) { | |
16157 fail(runString); | |
16158 return; | |
16159 } | |
16160 // (3) == null | |
16161 runString = "(3)"; | |
16162 if (null != jtt.lang.Class_getSuperClass01.test(3)) { | |
16163 fail(runString); | |
16164 return; | |
16165 } | |
16166 // (4) == "java.lang.Number" | |
16167 runString = "(4)"; | |
16168 if (!"java.lang.Number".equals(jtt.lang.Class_getSuperClass01 | |
16169 .test(4))) { | |
16170 fail(runString); | |
16171 return; | |
16172 } | |
16173 // (5) == "java.lang.Object" | |
16174 runString = "(5)"; | |
16175 if (!"java.lang.Object".equals(jtt.lang.Class_getSuperClass01 | |
16176 .test(5))) { | |
16177 fail(runString); | |
16178 return; | |
16179 } | |
16180 // (6) == "java.lang.Object" | |
16181 runString = "(6)"; | |
16182 if (!"java.lang.Object".equals(jtt.lang.Class_getSuperClass01 | |
16183 .test(6))) { | |
16184 fail(runString); | |
16185 return; | |
16186 } | |
16187 // (7) == null | |
16188 runString = "(7)"; | |
16189 if (null != jtt.lang.Class_getSuperClass01.test(7)) { | |
16190 fail(runString); | |
16191 return; | |
16192 } | |
16193 } catch (Throwable t) { | |
16194 fail(runString, t); | |
16195 return; | |
16196 } | |
16197 pass(); | |
16198 } | |
16199 | |
16200 static void jtt_lang_Class_isArray01() { | |
16201 begin("jtt.lang.Class_isArray01"); | |
16202 String runString = null; | |
16203 try { | |
16204 // (0) == false | |
16205 runString = "(0)"; | |
16206 if (false != jtt.lang.Class_isArray01.test(0)) { | |
16207 fail(runString); | |
16208 return; | |
16209 } | |
16210 // (1) == true | |
16211 runString = "(1)"; | |
16212 if (true != jtt.lang.Class_isArray01.test(1)) { | |
16213 fail(runString); | |
16214 return; | |
16215 } | |
16216 // (2) == false | |
16217 runString = "(2)"; | |
16218 if (false != jtt.lang.Class_isArray01.test(2)) { | |
16219 fail(runString); | |
16220 return; | |
16221 } | |
16222 // (3) == true | |
16223 runString = "(3)"; | |
16224 if (true != jtt.lang.Class_isArray01.test(3)) { | |
16225 fail(runString); | |
16226 return; | |
16227 } | |
16228 // (4) == false | |
16229 runString = "(4)"; | |
16230 if (false != jtt.lang.Class_isArray01.test(4)) { | |
16231 fail(runString); | |
16232 return; | |
16233 } | |
16234 // (5) == false | |
16235 runString = "(5)"; | |
16236 if (false != jtt.lang.Class_isArray01.test(5)) { | |
16237 fail(runString); | |
16238 return; | |
16239 } | |
16240 // (6) == false | |
16241 runString = "(6)"; | |
16242 if (false != jtt.lang.Class_isArray01.test(6)) { | |
16243 fail(runString); | |
16244 return; | |
16245 } | |
16246 // (7) == false | |
16247 runString = "(7)"; | |
16248 if (false != jtt.lang.Class_isArray01.test(7)) { | |
16249 fail(runString); | |
16250 return; | |
16251 } | |
16252 // (8) == false | |
16253 runString = "(8)"; | |
16254 if (false != jtt.lang.Class_isArray01.test(8)) { | |
16255 fail(runString); | |
16256 return; | |
16257 } | |
16258 } catch (Throwable t) { | |
16259 fail(runString, t); | |
16260 return; | |
16261 } | |
16262 pass(); | |
16263 } | |
16264 | |
16265 static void jtt_lang_Class_isAssignableFrom01() { | |
16266 begin("jtt.lang.Class_isAssignableFrom01"); | |
16267 String runString = null; | |
16268 try { | |
16269 // (0) == true | |
16270 runString = "(0)"; | |
16271 if (true != jtt.lang.Class_isAssignableFrom01.test(0)) { | |
16272 fail(runString); | |
16273 return; | |
16274 } | |
16275 // (1) == false | |
16276 runString = "(1)"; | |
16277 if (false != jtt.lang.Class_isAssignableFrom01.test(1)) { | |
16278 fail(runString); | |
16279 return; | |
16280 } | |
16281 // (2) == false | |
16282 runString = "(2)"; | |
16283 if (false != jtt.lang.Class_isAssignableFrom01.test(2)) { | |
16284 fail(runString); | |
16285 return; | |
16286 } | |
16287 // (3) == false | |
16288 runString = "(3)"; | |
16289 if (false != jtt.lang.Class_isAssignableFrom01.test(3)) { | |
16290 fail(runString); | |
16291 return; | |
16292 } | |
16293 // (4) == false | |
16294 runString = "(4)"; | |
16295 if (false != jtt.lang.Class_isAssignableFrom01.test(4)) { | |
16296 fail(runString); | |
16297 return; | |
16298 } | |
16299 // (5) == false | |
16300 runString = "(5)"; | |
16301 if (false != jtt.lang.Class_isAssignableFrom01.test(5)) { | |
16302 fail(runString); | |
16303 return; | |
16304 } | |
16305 // (6) == false | |
16306 runString = "(6)"; | |
16307 if (false != jtt.lang.Class_isAssignableFrom01.test(6)) { | |
16308 fail(runString); | |
16309 return; | |
16310 } | |
16311 // (7) == false | |
16312 runString = "(7)"; | |
16313 if (false != jtt.lang.Class_isAssignableFrom01.test(7)) { | |
16314 fail(runString); | |
16315 return; | |
16316 } | |
16317 } catch (Throwable t) { | |
16318 fail(runString, t); | |
16319 return; | |
16320 } | |
16321 pass(); | |
16322 } | |
16323 | |
16324 static void jtt_lang_Class_isAssignableFrom02() { | |
16325 begin("jtt.lang.Class_isAssignableFrom02"); | |
16326 String runString = null; | |
16327 try { | |
16328 // (0) == false | |
16329 runString = "(0)"; | |
16330 if (false != jtt.lang.Class_isAssignableFrom02.test(0)) { | |
16331 fail(runString); | |
16332 return; | |
16333 } | |
16334 // (1) == true | |
16335 runString = "(1)"; | |
16336 if (true != jtt.lang.Class_isAssignableFrom02.test(1)) { | |
16337 fail(runString); | |
16338 return; | |
16339 } | |
16340 // (2) == false | |
16341 runString = "(2)"; | |
16342 if (false != jtt.lang.Class_isAssignableFrom02.test(2)) { | |
16343 fail(runString); | |
16344 return; | |
16345 } | |
16346 // (3) == false | |
16347 runString = "(3)"; | |
16348 if (false != jtt.lang.Class_isAssignableFrom02.test(3)) { | |
16349 fail(runString); | |
16350 return; | |
16351 } | |
16352 // (4) == true | |
16353 runString = "(4)"; | |
16354 if (true != jtt.lang.Class_isAssignableFrom02.test(4)) { | |
16355 fail(runString); | |
16356 return; | |
16357 } | |
16358 // (5) == true | |
16359 runString = "(5)"; | |
16360 if (true != jtt.lang.Class_isAssignableFrom02.test(5)) { | |
16361 fail(runString); | |
16362 return; | |
16363 } | |
16364 // (6) == true | |
16365 runString = "(6)"; | |
16366 if (true != jtt.lang.Class_isAssignableFrom02.test(6)) { | |
16367 fail(runString); | |
16368 return; | |
16369 } | |
16370 // (7) == true | |
16371 runString = "(7)"; | |
16372 if (true != jtt.lang.Class_isAssignableFrom02.test(7)) { | |
16373 fail(runString); | |
16374 return; | |
16375 } | |
16376 } catch (Throwable t) { | |
16377 fail(runString, t); | |
16378 return; | |
16379 } | |
16380 pass(); | |
16381 } | |
16382 | |
16383 static void jtt_lang_Class_isAssignableFrom03() { | |
16384 begin("jtt.lang.Class_isAssignableFrom03"); | |
16385 String runString = null; | |
16386 try { | |
16387 // (0) == false | |
16388 runString = "(0)"; | |
16389 if (false != jtt.lang.Class_isAssignableFrom03.test(0)) { | |
16390 fail(runString); | |
16391 return; | |
16392 } | |
16393 // (1) == true | |
16394 runString = "(1)"; | |
16395 if (true != jtt.lang.Class_isAssignableFrom03.test(1)) { | |
16396 fail(runString); | |
16397 return; | |
16398 } | |
16399 // (2) == false | |
16400 runString = "(2)"; | |
16401 if (false != jtt.lang.Class_isAssignableFrom03.test(2)) { | |
16402 fail(runString); | |
16403 return; | |
16404 } | |
16405 // (3) == true | |
16406 runString = "(3)"; | |
16407 if (true != jtt.lang.Class_isAssignableFrom03.test(3)) { | |
16408 fail(runString); | |
16409 return; | |
16410 } | |
16411 // (4) == false | |
16412 runString = "(4)"; | |
16413 if (false != jtt.lang.Class_isAssignableFrom03.test(4)) { | |
16414 fail(runString); | |
16415 return; | |
16416 } | |
16417 // (5) == true | |
16418 runString = "(5)"; | |
16419 if (true != jtt.lang.Class_isAssignableFrom03.test(5)) { | |
16420 fail(runString); | |
16421 return; | |
16422 } | |
16423 // (6) == true | |
16424 runString = "(6)"; | |
16425 if (true != jtt.lang.Class_isAssignableFrom03.test(6)) { | |
16426 fail(runString); | |
16427 return; | |
16428 } | |
16429 // (7) == false | |
16430 runString = "(7)"; | |
16431 if (false != jtt.lang.Class_isAssignableFrom03.test(7)) { | |
16432 fail(runString); | |
16433 return; | |
16434 } | |
16435 } catch (Throwable t) { | |
16436 fail(runString, t); | |
16437 return; | |
16438 } | |
16439 pass(); | |
16440 } | |
16441 | |
16442 static void jtt_lang_Class_isInstance01() { | |
16443 begin("jtt.lang.Class_isInstance01"); | |
16444 String runString = null; | |
16445 try { | |
16446 // (0) == true | |
16447 runString = "(0)"; | |
16448 if (true != jtt.lang.Class_isInstance01.test(0)) { | |
16449 fail(runString); | |
16450 return; | |
16451 } | |
16452 // (1) == true | |
16453 runString = "(1)"; | |
16454 if (true != jtt.lang.Class_isInstance01.test(1)) { | |
16455 fail(runString); | |
16456 return; | |
16457 } | |
16458 // (2) == true | |
16459 runString = "(2)"; | |
16460 if (true != jtt.lang.Class_isInstance01.test(2)) { | |
16461 fail(runString); | |
16462 return; | |
16463 } | |
16464 // (3) == false | |
16465 runString = "(3)"; | |
16466 if (false != jtt.lang.Class_isInstance01.test(3)) { | |
16467 fail(runString); | |
16468 return; | |
16469 } | |
16470 } catch (Throwable t) { | |
16471 fail(runString, t); | |
16472 return; | |
16473 } | |
16474 pass(); | |
16475 } | |
16476 | |
16477 static void jtt_lang_Class_isInstance02() { | |
16478 begin("jtt.lang.Class_isInstance02"); | |
16479 String runString = null; | |
16480 try { | |
16481 // (0) == false | |
16482 runString = "(0)"; | |
16483 if (false != jtt.lang.Class_isInstance02.test(0)) { | |
16484 fail(runString); | |
16485 return; | |
16486 } | |
16487 // (1) == true | |
16488 runString = "(1)"; | |
16489 if (true != jtt.lang.Class_isInstance02.test(1)) { | |
16490 fail(runString); | |
16491 return; | |
16492 } | |
16493 // (2) == false | |
16494 runString = "(2)"; | |
16495 if (false != jtt.lang.Class_isInstance02.test(2)) { | |
16496 fail(runString); | |
16497 return; | |
16498 } | |
16499 // (3) == false | |
16500 runString = "(3)"; | |
16501 if (false != jtt.lang.Class_isInstance02.test(3)) { | |
16502 fail(runString); | |
16503 return; | |
16504 } | |
16505 } catch (Throwable t) { | |
16506 fail(runString, t); | |
16507 return; | |
16508 } | |
16509 pass(); | |
16510 } | |
16511 | |
16512 static void jtt_lang_Class_isInstance03() { | |
16513 begin("jtt.lang.Class_isInstance03"); | |
16514 String runString = null; | |
16515 try { | |
16516 // (0) == false | |
16517 runString = "(0)"; | |
16518 if (false != jtt.lang.Class_isInstance03.test(0)) { | |
16519 fail(runString); | |
16520 return; | |
16521 } | |
16522 // (1) == false | |
16523 runString = "(1)"; | |
16524 if (false != jtt.lang.Class_isInstance03.test(1)) { | |
16525 fail(runString); | |
16526 return; | |
16527 } | |
16528 // (2) == true | |
16529 runString = "(2)"; | |
16530 if (true != jtt.lang.Class_isInstance03.test(2)) { | |
16531 fail(runString); | |
16532 return; | |
16533 } | |
16534 // (3) == false | |
16535 runString = "(3)"; | |
16536 if (false != jtt.lang.Class_isInstance03.test(3)) { | |
16537 fail(runString); | |
16538 return; | |
16539 } | |
16540 } catch (Throwable t) { | |
16541 fail(runString, t); | |
16542 return; | |
16543 } | |
16544 pass(); | |
16545 } | |
16546 | |
16547 static void jtt_lang_Class_isInstance04() { | |
16548 begin("jtt.lang.Class_isInstance04"); | |
16549 String runString = null; | |
16550 try { | |
16551 // (0) == false | |
16552 runString = "(0)"; | |
16553 if (false != jtt.lang.Class_isInstance04.test(0)) { | |
16554 fail(runString); | |
16555 return; | |
16556 } | |
16557 // (1) == false | |
16558 runString = "(1)"; | |
16559 if (false != jtt.lang.Class_isInstance04.test(1)) { | |
16560 fail(runString); | |
16561 return; | |
16562 } | |
16563 // (2) == true | |
16564 runString = "(2)"; | |
16565 if (true != jtt.lang.Class_isInstance04.test(2)) { | |
16566 fail(runString); | |
16567 return; | |
16568 } | |
16569 // (3) == false | |
16570 runString = "(3)"; | |
16571 if (false != jtt.lang.Class_isInstance04.test(3)) { | |
16572 fail(runString); | |
16573 return; | |
16574 } | |
16575 } catch (Throwable t) { | |
16576 fail(runString, t); | |
16577 return; | |
16578 } | |
16579 pass(); | |
16580 } | |
16581 | |
16582 static void jtt_lang_Class_isInstance05() { | |
16583 begin("jtt.lang.Class_isInstance05"); | |
16584 String runString = null; | |
16585 try { | |
16586 // (0) == false | |
16587 runString = "(0)"; | |
16588 if (false != jtt.lang.Class_isInstance05.test(0)) { | |
16589 fail(runString); | |
16590 return; | |
16591 } | |
16592 // (1) == false | |
16593 runString = "(1)"; | |
16594 if (false != jtt.lang.Class_isInstance05.test(1)) { | |
16595 fail(runString); | |
16596 return; | |
16597 } | |
16598 // (2) == true | |
16599 runString = "(2)"; | |
16600 if (true != jtt.lang.Class_isInstance05.test(2)) { | |
16601 fail(runString); | |
16602 return; | |
16603 } | |
16604 // (3) == false | |
16605 runString = "(3)"; | |
16606 if (false != jtt.lang.Class_isInstance05.test(3)) { | |
16607 fail(runString); | |
16608 return; | |
16609 } | |
16610 } catch (Throwable t) { | |
16611 fail(runString, t); | |
16612 return; | |
16613 } | |
16614 pass(); | |
16615 } | |
16616 | |
16617 static void jtt_lang_Class_isInstance06() { | |
16618 begin("jtt.lang.Class_isInstance06"); | |
16619 String runString = null; | |
16620 try { | |
16621 // (0) == false | |
16622 runString = "(0)"; | |
16623 if (false != jtt.lang.Class_isInstance06.test(0)) { | |
16624 fail(runString); | |
16625 return; | |
16626 } | |
16627 // (1) == false | |
16628 runString = "(1)"; | |
16629 if (false != jtt.lang.Class_isInstance06.test(1)) { | |
16630 fail(runString); | |
16631 return; | |
16632 } | |
16633 // (2) == true | |
16634 runString = "(2)"; | |
16635 if (true != jtt.lang.Class_isInstance06.test(2)) { | |
16636 fail(runString); | |
16637 return; | |
16638 } | |
16639 // (3) == true | |
16640 runString = "(3)"; | |
16641 if (true != jtt.lang.Class_isInstance06.test(3)) { | |
16642 fail(runString); | |
16643 return; | |
16644 } | |
16645 // (4) == false | |
16646 runString = "(4)"; | |
16647 if (false != jtt.lang.Class_isInstance06.test(4)) { | |
16648 fail(runString); | |
16649 return; | |
16650 } | |
16651 } catch (Throwable t) { | |
16652 fail(runString, t); | |
16653 return; | |
16654 } | |
16655 pass(); | |
16656 } | |
16657 | |
16658 static void jtt_lang_Class_isInterface01() { | |
16659 begin("jtt.lang.Class_isInterface01"); | |
16660 String runString = null; | |
16661 try { | |
16662 // (0) == false | |
16663 runString = "(0)"; | |
16664 if (false != jtt.lang.Class_isInterface01.test(0)) { | |
16665 fail(runString); | |
16666 return; | |
16667 } | |
16668 // (1) == false | |
16669 runString = "(1)"; | |
16670 if (false != jtt.lang.Class_isInterface01.test(1)) { | |
16671 fail(runString); | |
16672 return; | |
16673 } | |
16674 // (2) == false | |
16675 runString = "(2)"; | |
16676 if (false != jtt.lang.Class_isInterface01.test(2)) { | |
16677 fail(runString); | |
16678 return; | |
16679 } | |
16680 // (3) == false | |
16681 runString = "(3)"; | |
16682 if (false != jtt.lang.Class_isInterface01.test(3)) { | |
16683 fail(runString); | |
16684 return; | |
16685 } | |
16686 // (4) == false | |
16687 runString = "(4)"; | |
16688 if (false != jtt.lang.Class_isInterface01.test(4)) { | |
16689 fail(runString); | |
16690 return; | |
16691 } | |
16692 // (5) == true | |
16693 runString = "(5)"; | |
16694 if (true != jtt.lang.Class_isInterface01.test(5)) { | |
16695 fail(runString); | |
16696 return; | |
16697 } | |
16698 // (6) == true | |
16699 runString = "(6)"; | |
16700 if (true != jtt.lang.Class_isInterface01.test(6)) { | |
16701 fail(runString); | |
16702 return; | |
16703 } | |
16704 // (7) == false | |
16705 runString = "(7)"; | |
16706 if (false != jtt.lang.Class_isInterface01.test(7)) { | |
16707 fail(runString); | |
16708 return; | |
16709 } | |
16710 // (8) == false | |
16711 runString = "(8)"; | |
16712 if (false != jtt.lang.Class_isInterface01.test(8)) { | |
16713 fail(runString); | |
16714 return; | |
16715 } | |
16716 } catch (Throwable t) { | |
16717 fail(runString, t); | |
16718 return; | |
16719 } | |
16720 pass(); | |
16721 } | |
16722 | |
16723 static void jtt_lang_Class_isPrimitive01() { | |
16724 begin("jtt.lang.Class_isPrimitive01"); | |
16725 String runString = null; | |
16726 try { | |
16727 // (0) == true | |
16728 runString = "(0)"; | |
16729 if (true != jtt.lang.Class_isPrimitive01.test(0)) { | |
16730 fail(runString); | |
16731 return; | |
16732 } | |
16733 // (1) == false | |
16734 runString = "(1)"; | |
16735 if (false != jtt.lang.Class_isPrimitive01.test(1)) { | |
16736 fail(runString); | |
16737 return; | |
16738 } | |
16739 // (2) == false | |
16740 runString = "(2)"; | |
16741 if (false != jtt.lang.Class_isPrimitive01.test(2)) { | |
16742 fail(runString); | |
16743 return; | |
16744 } | |
16745 // (3) == false | |
16746 runString = "(3)"; | |
16747 if (false != jtt.lang.Class_isPrimitive01.test(3)) { | |
16748 fail(runString); | |
16749 return; | |
16750 } | |
16751 // (4) == false | |
16752 runString = "(4)"; | |
16753 if (false != jtt.lang.Class_isPrimitive01.test(4)) { | |
16754 fail(runString); | |
16755 return; | |
16756 } | |
16757 // (5) == false | |
16758 runString = "(5)"; | |
16759 if (false != jtt.lang.Class_isPrimitive01.test(5)) { | |
16760 fail(runString); | |
16761 return; | |
16762 } | |
16763 // (6) == false | |
16764 runString = "(6)"; | |
16765 if (false != jtt.lang.Class_isPrimitive01.test(6)) { | |
16766 fail(runString); | |
16767 return; | |
16768 } | |
16769 // (7) == true | |
16770 runString = "(7)"; | |
16771 if (true != jtt.lang.Class_isPrimitive01.test(7)) { | |
16772 fail(runString); | |
16773 return; | |
16774 } | |
16775 // (8) == false | |
16776 runString = "(8)"; | |
16777 if (false != jtt.lang.Class_isPrimitive01.test(8)) { | |
16778 fail(runString); | |
16779 return; | |
16780 } | |
16781 } catch (Throwable t) { | |
16782 fail(runString, t); | |
16783 return; | |
16784 } | |
16785 pass(); | |
16786 } | |
16787 | |
16788 static void jtt_lang_Double_toString() { | |
16789 begin("jtt.lang.Double_toString"); | |
16790 String runString = null; | |
16791 try { | |
16792 // (0) == "9.834050399508132E-4" | |
16793 runString = "(0)"; | |
16794 if (!"9.834050399508132E-4" | |
16795 .equals(jtt.lang.Double_toString.test(0))) { | |
16796 fail(runString); | |
16797 return; | |
16798 } | |
16799 } catch (Throwable t) { | |
16800 fail(runString, t); | |
16801 return; | |
16802 } | |
16803 pass(); | |
16804 } | |
16805 | |
16806 static void jtt_lang_Float_01() { | |
16807 begin("jtt.lang.Float_01"); | |
16808 String runString = null; | |
16809 try { | |
16810 // (1.0) == false | |
16811 runString = "(1.0)"; | |
16812 if (false != jtt.lang.Float_01.test(1.0f)) { | |
16813 fail(runString); | |
16814 return; | |
16815 } | |
16816 // (2.0) == false | |
16817 runString = "(2.0)"; | |
16818 if (false != jtt.lang.Float_01.test(2.0f)) { | |
16819 fail(runString); | |
16820 return; | |
16821 } | |
16822 // (0.5) == false | |
16823 runString = "(0.5)"; | |
16824 if (false != jtt.lang.Float_01.test(0.5f)) { | |
16825 fail(runString); | |
16826 return; | |
16827 } | |
16828 // (java.lang.Float.NaN) == true | |
16829 runString = "(java.lang.Float.NaN)"; | |
16830 if (true != jtt.lang.Float_01.test(java.lang.Float.NaN)) { | |
16831 fail(runString); | |
16832 return; | |
16833 } | |
16834 } catch (Throwable t) { | |
16835 fail(runString, t); | |
16836 return; | |
16837 } | |
16838 pass(); | |
16839 } | |
16840 | |
16841 static void jtt_lang_Float_02() { | |
16842 begin("jtt.lang.Float_02"); | |
16843 String runString = null; | |
16844 try { | |
16845 // (1.0) == false | |
16846 runString = "(1.0)"; | |
16847 if (false != jtt.lang.Float_02.test(1.0f)) { | |
16848 fail(runString); | |
16849 return; | |
16850 } | |
16851 // (2.0) == true | |
16852 runString = "(2.0)"; | |
16853 if (true != jtt.lang.Float_02.test(2.0f)) { | |
16854 fail(runString); | |
16855 return; | |
16856 } | |
16857 // (0.5) == true | |
16858 runString = "(0.5)"; | |
16859 if (true != jtt.lang.Float_02.test(0.5f)) { | |
16860 fail(runString); | |
16861 return; | |
16862 } | |
16863 // (java.lang.Float.NaN) == true | |
16864 runString = "(java.lang.Float.NaN)"; | |
16865 if (true != jtt.lang.Float_02.test(java.lang.Float.NaN)) { | |
16866 fail(runString); | |
16867 return; | |
16868 } | |
16869 } catch (Throwable t) { | |
16870 fail(runString, t); | |
16871 return; | |
16872 } | |
16873 pass(); | |
16874 } | |
16875 | |
16876 static void jtt_lang_Int_greater01() { | |
16877 begin("jtt.lang.Int_greater01"); | |
16878 String runString = null; | |
16879 try { | |
16880 // (-2147483648) == false | |
16881 runString = "(-2147483648)"; | |
16882 if (false != jtt.lang.Int_greater01.test(-2147483648)) { | |
16883 fail(runString); | |
16884 return; | |
16885 } | |
16886 // (-2) == false | |
16887 runString = "(-2)"; | |
16888 if (false != jtt.lang.Int_greater01.test(-2)) { | |
16889 fail(runString); | |
16890 return; | |
16891 } | |
16892 // (-1) == false | |
16893 runString = "(-1)"; | |
16894 if (false != jtt.lang.Int_greater01.test(-1)) { | |
16895 fail(runString); | |
16896 return; | |
16897 } | |
16898 // (0) == false | |
16899 runString = "(0)"; | |
16900 if (false != jtt.lang.Int_greater01.test(0)) { | |
16901 fail(runString); | |
16902 return; | |
16903 } | |
16904 // (1) == true | |
16905 runString = "(1)"; | |
16906 if (true != jtt.lang.Int_greater01.test(1)) { | |
16907 fail(runString); | |
16908 return; | |
16909 } | |
16910 // (2) == true | |
16911 runString = "(2)"; | |
16912 if (true != jtt.lang.Int_greater01.test(2)) { | |
16913 fail(runString); | |
16914 return; | |
16915 } | |
16916 // (2147483647) == true | |
16917 runString = "(2147483647)"; | |
16918 if (true != jtt.lang.Int_greater01.test(2147483647)) { | |
16919 fail(runString); | |
16920 return; | |
16921 } | |
16922 } catch (Throwable t) { | |
16923 fail(runString, t); | |
16924 return; | |
16925 } | |
16926 pass(); | |
16927 } | |
16928 | |
16929 static void jtt_lang_Int_greater02() { | |
16930 begin("jtt.lang.Int_greater02"); | |
16931 String runString = null; | |
16932 try { | |
16933 // (-2147483648) == false | |
16934 runString = "(-2147483648)"; | |
16935 if (false != jtt.lang.Int_greater02.test(-2147483648)) { | |
16936 fail(runString); | |
16937 return; | |
16938 } | |
16939 // (-2) == false | |
16940 runString = "(-2)"; | |
16941 if (false != jtt.lang.Int_greater02.test(-2)) { | |
16942 fail(runString); | |
16943 return; | |
16944 } | |
16945 // (-1) == false | |
16946 runString = "(-1)"; | |
16947 if (false != jtt.lang.Int_greater02.test(-1)) { | |
16948 fail(runString); | |
16949 return; | |
16950 } | |
16951 // (0) == false | |
16952 runString = "(0)"; | |
16953 if (false != jtt.lang.Int_greater02.test(0)) { | |
16954 fail(runString); | |
16955 return; | |
16956 } | |
16957 // (1) == false | |
16958 runString = "(1)"; | |
16959 if (false != jtt.lang.Int_greater02.test(1)) { | |
16960 fail(runString); | |
16961 return; | |
16962 } | |
16963 // (4) == false | |
16964 runString = "(4)"; | |
16965 if (false != jtt.lang.Int_greater02.test(4)) { | |
16966 fail(runString); | |
16967 return; | |
16968 } | |
16969 // (5) == false | |
16970 runString = "(5)"; | |
16971 if (false != jtt.lang.Int_greater02.test(5)) { | |
16972 fail(runString); | |
16973 return; | |
16974 } | |
16975 // (6) == true | |
16976 runString = "(6)"; | |
16977 if (true != jtt.lang.Int_greater02.test(6)) { | |
16978 fail(runString); | |
16979 return; | |
16980 } | |
16981 // (2147483647) == true | |
16982 runString = "(2147483647)"; | |
16983 if (true != jtt.lang.Int_greater02.test(2147483647)) { | |
16984 fail(runString); | |
16985 return; | |
16986 } | |
16987 } catch (Throwable t) { | |
16988 fail(runString, t); | |
16989 return; | |
16990 } | |
16991 pass(); | |
16992 } | |
16993 | |
16994 static void jtt_lang_Int_greater03() { | |
16995 begin("jtt.lang.Int_greater03"); | |
16996 String runString = null; | |
16997 try { | |
16998 // (-2147483648) == false | |
16999 runString = "(-2147483648)"; | |
17000 if (false != jtt.lang.Int_greater03.test(-2147483648)) { | |
17001 fail(runString); | |
17002 return; | |
17003 } | |
17004 // (-6) == false | |
17005 runString = "(-6)"; | |
17006 if (false != jtt.lang.Int_greater03.test(-6)) { | |
17007 fail(runString); | |
17008 return; | |
17009 } | |
17010 // (-5) == false | |
17011 runString = "(-5)"; | |
17012 if (false != jtt.lang.Int_greater03.test(-5)) { | |
17013 fail(runString); | |
17014 return; | |
17015 } | |
17016 // (-4) == true | |
17017 runString = "(-4)"; | |
17018 if (true != jtt.lang.Int_greater03.test(-4)) { | |
17019 fail(runString); | |
17020 return; | |
17021 } | |
17022 // (-1) == true | |
17023 runString = "(-1)"; | |
17024 if (true != jtt.lang.Int_greater03.test(-1)) { | |
17025 fail(runString); | |
17026 return; | |
17027 } | |
17028 // (0) == true | |
17029 runString = "(0)"; | |
17030 if (true != jtt.lang.Int_greater03.test(0)) { | |
17031 fail(runString); | |
17032 return; | |
17033 } | |
17034 // (1) == true | |
17035 runString = "(1)"; | |
17036 if (true != jtt.lang.Int_greater03.test(1)) { | |
17037 fail(runString); | |
17038 return; | |
17039 } | |
17040 // (2) == true | |
17041 runString = "(2)"; | |
17042 if (true != jtt.lang.Int_greater03.test(2)) { | |
17043 fail(runString); | |
17044 return; | |
17045 } | |
17046 // (2147483647) == true | |
17047 runString = "(2147483647)"; | |
17048 if (true != jtt.lang.Int_greater03.test(2147483647)) { | |
17049 fail(runString); | |
17050 return; | |
17051 } | |
17052 } catch (Throwable t) { | |
17053 fail(runString, t); | |
17054 return; | |
17055 } | |
17056 pass(); | |
17057 } | |
17058 | |
17059 static void jtt_lang_Int_greaterEqual01() { | |
17060 begin("jtt.lang.Int_greaterEqual01"); | |
17061 String runString = null; | |
17062 try { | |
17063 // (-2147483648) == false | |
17064 runString = "(-2147483648)"; | |
17065 if (false != jtt.lang.Int_greaterEqual01.test(-2147483648)) { | |
17066 fail(runString); | |
17067 return; | |
17068 } | |
17069 // (-2) == false | |
17070 runString = "(-2)"; | |
17071 if (false != jtt.lang.Int_greaterEqual01.test(-2)) { | |
17072 fail(runString); | |
17073 return; | |
17074 } | |
17075 // (-1) == false | |
17076 runString = "(-1)"; | |
17077 if (false != jtt.lang.Int_greaterEqual01.test(-1)) { | |
17078 fail(runString); | |
17079 return; | |
17080 } | |
17081 // (0) == true | |
17082 runString = "(0)"; | |
17083 if (true != jtt.lang.Int_greaterEqual01.test(0)) { | |
17084 fail(runString); | |
17085 return; | |
17086 } | |
17087 // (1) == true | |
17088 runString = "(1)"; | |
17089 if (true != jtt.lang.Int_greaterEqual01.test(1)) { | |
17090 fail(runString); | |
17091 return; | |
17092 } | |
17093 // (2) == true | |
17094 runString = "(2)"; | |
17095 if (true != jtt.lang.Int_greaterEqual01.test(2)) { | |
17096 fail(runString); | |
17097 return; | |
17098 } | |
17099 // (2147483647) == true | |
17100 runString = "(2147483647)"; | |
17101 if (true != jtt.lang.Int_greaterEqual01.test(2147483647)) { | |
17102 fail(runString); | |
17103 return; | |
17104 } | |
17105 } catch (Throwable t) { | |
17106 fail(runString, t); | |
17107 return; | |
17108 } | |
17109 pass(); | |
17110 } | |
17111 | |
17112 static void jtt_lang_Int_greaterEqual02() { | |
17113 begin("jtt.lang.Int_greaterEqual02"); | |
17114 String runString = null; | |
17115 try { | |
17116 // (-2147483648) == false | |
17117 runString = "(-2147483648)"; | |
17118 if (false != jtt.lang.Int_greaterEqual02.test(-2147483648)) { | |
17119 fail(runString); | |
17120 return; | |
17121 } | |
17122 // (-2) == false | |
17123 runString = "(-2)"; | |
17124 if (false != jtt.lang.Int_greaterEqual02.test(-2)) { | |
17125 fail(runString); | |
17126 return; | |
17127 } | |
17128 // (-1) == false | |
17129 runString = "(-1)"; | |
17130 if (false != jtt.lang.Int_greaterEqual02.test(-1)) { | |
17131 fail(runString); | |
17132 return; | |
17133 } | |
17134 // (0) == false | |
17135 runString = "(0)"; | |
17136 if (false != jtt.lang.Int_greaterEqual02.test(0)) { | |
17137 fail(runString); | |
17138 return; | |
17139 } | |
17140 // (1) == false | |
17141 runString = "(1)"; | |
17142 if (false != jtt.lang.Int_greaterEqual02.test(1)) { | |
17143 fail(runString); | |
17144 return; | |
17145 } | |
17146 // (4) == false | |
17147 runString = "(4)"; | |
17148 if (false != jtt.lang.Int_greaterEqual02.test(4)) { | |
17149 fail(runString); | |
17150 return; | |
17151 } | |
17152 // (5) == true | |
17153 runString = "(5)"; | |
17154 if (true != jtt.lang.Int_greaterEqual02.test(5)) { | |
17155 fail(runString); | |
17156 return; | |
17157 } | |
17158 // (6) == true | |
17159 runString = "(6)"; | |
17160 if (true != jtt.lang.Int_greaterEqual02.test(6)) { | |
17161 fail(runString); | |
17162 return; | |
17163 } | |
17164 // (2147483647) == true | |
17165 runString = "(2147483647)"; | |
17166 if (true != jtt.lang.Int_greaterEqual02.test(2147483647)) { | |
17167 fail(runString); | |
17168 return; | |
17169 } | |
17170 } catch (Throwable t) { | |
17171 fail(runString, t); | |
17172 return; | |
17173 } | |
17174 pass(); | |
17175 } | |
17176 | |
17177 static void jtt_lang_Int_greaterEqual03() { | |
17178 begin("jtt.lang.Int_greaterEqual03"); | |
17179 String runString = null; | |
17180 try { | |
17181 // (-2147483648) == false | |
17182 runString = "(-2147483648)"; | |
17183 if (false != jtt.lang.Int_greaterEqual03.test(-2147483648)) { | |
17184 fail(runString); | |
17185 return; | |
17186 } | |
17187 // (-6) == false | |
17188 runString = "(-6)"; | |
17189 if (false != jtt.lang.Int_greaterEqual03.test(-6)) { | |
17190 fail(runString); | |
17191 return; | |
17192 } | |
17193 // (-5) == true | |
17194 runString = "(-5)"; | |
17195 if (true != jtt.lang.Int_greaterEqual03.test(-5)) { | |
17196 fail(runString); | |
17197 return; | |
17198 } | |
17199 // (-4) == true | |
17200 runString = "(-4)"; | |
17201 if (true != jtt.lang.Int_greaterEqual03.test(-4)) { | |
17202 fail(runString); | |
17203 return; | |
17204 } | |
17205 // (-1) == true | |
17206 runString = "(-1)"; | |
17207 if (true != jtt.lang.Int_greaterEqual03.test(-1)) { | |
17208 fail(runString); | |
17209 return; | |
17210 } | |
17211 // (0) == true | |
17212 runString = "(0)"; | |
17213 if (true != jtt.lang.Int_greaterEqual03.test(0)) { | |
17214 fail(runString); | |
17215 return; | |
17216 } | |
17217 // (1) == true | |
17218 runString = "(1)"; | |
17219 if (true != jtt.lang.Int_greaterEqual03.test(1)) { | |
17220 fail(runString); | |
17221 return; | |
17222 } | |
17223 // (2) == true | |
17224 runString = "(2)"; | |
17225 if (true != jtt.lang.Int_greaterEqual03.test(2)) { | |
17226 fail(runString); | |
17227 return; | |
17228 } | |
17229 // (2147483647) == true | |
17230 runString = "(2147483647)"; | |
17231 if (true != jtt.lang.Int_greaterEqual03.test(2147483647)) { | |
17232 fail(runString); | |
17233 return; | |
17234 } | |
17235 } catch (Throwable t) { | |
17236 fail(runString, t); | |
17237 return; | |
17238 } | |
17239 pass(); | |
17240 } | |
17241 | |
17242 static void jtt_lang_Int_less01() { | |
17243 begin("jtt.lang.Int_less01"); | |
17244 String runString = null; | |
17245 try { | |
17246 // (-2147483648) == true | |
17247 runString = "(-2147483648)"; | |
17248 if (true != jtt.lang.Int_less01.test(-2147483648)) { | |
17249 fail(runString); | |
17250 return; | |
17251 } | |
17252 // (-2) == true | |
17253 runString = "(-2)"; | |
17254 if (true != jtt.lang.Int_less01.test(-2)) { | |
17255 fail(runString); | |
17256 return; | |
17257 } | |
17258 // (-1) == true | |
17259 runString = "(-1)"; | |
17260 if (true != jtt.lang.Int_less01.test(-1)) { | |
17261 fail(runString); | |
17262 return; | |
17263 } | |
17264 // (0) == false | |
17265 runString = "(0)"; | |
17266 if (false != jtt.lang.Int_less01.test(0)) { | |
17267 fail(runString); | |
17268 return; | |
17269 } | |
17270 // (1) == false | |
17271 runString = "(1)"; | |
17272 if (false != jtt.lang.Int_less01.test(1)) { | |
17273 fail(runString); | |
17274 return; | |
17275 } | |
17276 // (2) == false | |
17277 runString = "(2)"; | |
17278 if (false != jtt.lang.Int_less01.test(2)) { | |
17279 fail(runString); | |
17280 return; | |
17281 } | |
17282 // (2147483647) == false | |
17283 runString = "(2147483647)"; | |
17284 if (false != jtt.lang.Int_less01.test(2147483647)) { | |
17285 fail(runString); | |
17286 return; | |
17287 } | |
17288 } catch (Throwable t) { | |
17289 fail(runString, t); | |
17290 return; | |
17291 } | |
17292 pass(); | |
17293 } | |
17294 | |
17295 static void jtt_lang_Int_less02() { | |
17296 begin("jtt.lang.Int_less02"); | |
17297 String runString = null; | |
17298 try { | |
17299 // (-2147483648) == true | |
17300 runString = "(-2147483648)"; | |
17301 if (true != jtt.lang.Int_less02.test(-2147483648)) { | |
17302 fail(runString); | |
17303 return; | |
17304 } | |
17305 // (-2) == true | |
17306 runString = "(-2)"; | |
17307 if (true != jtt.lang.Int_less02.test(-2)) { | |
17308 fail(runString); | |
17309 return; | |
17310 } | |
17311 // (-1) == true | |
17312 runString = "(-1)"; | |
17313 if (true != jtt.lang.Int_less02.test(-1)) { | |
17314 fail(runString); | |
17315 return; | |
17316 } | |
17317 // (0) == true | |
17318 runString = "(0)"; | |
17319 if (true != jtt.lang.Int_less02.test(0)) { | |
17320 fail(runString); | |
17321 return; | |
17322 } | |
17323 // (4) == true | |
17324 runString = "(4)"; | |
17325 if (true != jtt.lang.Int_less02.test(4)) { | |
17326 fail(runString); | |
17327 return; | |
17328 } | |
17329 // (5) == false | |
17330 runString = "(5)"; | |
17331 if (false != jtt.lang.Int_less02.test(5)) { | |
17332 fail(runString); | |
17333 return; | |
17334 } | |
17335 // (6) == false | |
17336 runString = "(6)"; | |
17337 if (false != jtt.lang.Int_less02.test(6)) { | |
17338 fail(runString); | |
17339 return; | |
17340 } | |
17341 // (2147483647) == false | |
17342 runString = "(2147483647)"; | |
17343 if (false != jtt.lang.Int_less02.test(2147483647)) { | |
17344 fail(runString); | |
17345 return; | |
17346 } | |
17347 } catch (Throwable t) { | |
17348 fail(runString, t); | |
17349 return; | |
17350 } | |
17351 pass(); | |
17352 } | |
17353 | |
17354 static void jtt_lang_Int_less03() { | |
17355 begin("jtt.lang.Int_less03"); | |
17356 String runString = null; | |
17357 try { | |
17358 // (-2147483648) == true | |
17359 runString = "(-2147483648)"; | |
17360 if (true != jtt.lang.Int_less03.test(-2147483648)) { | |
17361 fail(runString); | |
17362 return; | |
17363 } | |
17364 // (-6) == true | |
17365 runString = "(-6)"; | |
17366 if (true != jtt.lang.Int_less03.test(-6)) { | |
17367 fail(runString); | |
17368 return; | |
17369 } | |
17370 // (-5) == false | |
17371 runString = "(-5)"; | |
17372 if (false != jtt.lang.Int_less03.test(-5)) { | |
17373 fail(runString); | |
17374 return; | |
17375 } | |
17376 // (-4) == false | |
17377 runString = "(-4)"; | |
17378 if (false != jtt.lang.Int_less03.test(-4)) { | |
17379 fail(runString); | |
17380 return; | |
17381 } | |
17382 // (-1) == false | |
17383 runString = "(-1)"; | |
17384 if (false != jtt.lang.Int_less03.test(-1)) { | |
17385 fail(runString); | |
17386 return; | |
17387 } | |
17388 // (0) == false | |
17389 runString = "(0)"; | |
17390 if (false != jtt.lang.Int_less03.test(0)) { | |
17391 fail(runString); | |
17392 return; | |
17393 } | |
17394 // (1) == false | |
17395 runString = "(1)"; | |
17396 if (false != jtt.lang.Int_less03.test(1)) { | |
17397 fail(runString); | |
17398 return; | |
17399 } | |
17400 // (2) == false | |
17401 runString = "(2)"; | |
17402 if (false != jtt.lang.Int_less03.test(2)) { | |
17403 fail(runString); | |
17404 return; | |
17405 } | |
17406 // (2147483647) == false | |
17407 runString = "(2147483647)"; | |
17408 if (false != jtt.lang.Int_less03.test(2147483647)) { | |
17409 fail(runString); | |
17410 return; | |
17411 } | |
17412 } catch (Throwable t) { | |
17413 fail(runString, t); | |
17414 return; | |
17415 } | |
17416 pass(); | |
17417 } | |
17418 | |
17419 static void jtt_lang_Int_lessEqual01() { | |
17420 begin("jtt.lang.Int_lessEqual01"); | |
17421 String runString = null; | |
17422 try { | |
17423 // (-2147483648) == true | |
17424 runString = "(-2147483648)"; | |
17425 if (true != jtt.lang.Int_lessEqual01.test(-2147483648)) { | |
17426 fail(runString); | |
17427 return; | |
17428 } | |
17429 // (-2) == true | |
17430 runString = "(-2)"; | |
17431 if (true != jtt.lang.Int_lessEqual01.test(-2)) { | |
17432 fail(runString); | |
17433 return; | |
17434 } | |
17435 // (-1) == true | |
17436 runString = "(-1)"; | |
17437 if (true != jtt.lang.Int_lessEqual01.test(-1)) { | |
17438 fail(runString); | |
17439 return; | |
17440 } | |
17441 // (0) == true | |
17442 runString = "(0)"; | |
17443 if (true != jtt.lang.Int_lessEqual01.test(0)) { | |
17444 fail(runString); | |
17445 return; | |
17446 } | |
17447 // (1) == false | |
17448 runString = "(1)"; | |
17449 if (false != jtt.lang.Int_lessEqual01.test(1)) { | |
17450 fail(runString); | |
17451 return; | |
17452 } | |
17453 // (2) == false | |
17454 runString = "(2)"; | |
17455 if (false != jtt.lang.Int_lessEqual01.test(2)) { | |
17456 fail(runString); | |
17457 return; | |
17458 } | |
17459 // (2147483647) == false | |
17460 runString = "(2147483647)"; | |
17461 if (false != jtt.lang.Int_lessEqual01.test(2147483647)) { | |
17462 fail(runString); | |
17463 return; | |
17464 } | |
17465 } catch (Throwable t) { | |
17466 fail(runString, t); | |
17467 return; | |
17468 } | |
17469 pass(); | |
17470 } | |
17471 | |
17472 static void jtt_lang_Int_lessEqual02() { | |
17473 begin("jtt.lang.Int_lessEqual02"); | |
17474 String runString = null; | |
17475 try { | |
17476 // (-2147483648) == true | |
17477 runString = "(-2147483648)"; | |
17478 if (true != jtt.lang.Int_lessEqual02.test(-2147483648)) { | |
17479 fail(runString); | |
17480 return; | |
17481 } | |
17482 // (-2) == true | |
17483 runString = "(-2)"; | |
17484 if (true != jtt.lang.Int_lessEqual02.test(-2)) { | |
17485 fail(runString); | |
17486 return; | |
17487 } | |
17488 // (-1) == true | |
17489 runString = "(-1)"; | |
17490 if (true != jtt.lang.Int_lessEqual02.test(-1)) { | |
17491 fail(runString); | |
17492 return; | |
17493 } | |
17494 // (0) == true | |
17495 runString = "(0)"; | |
17496 if (true != jtt.lang.Int_lessEqual02.test(0)) { | |
17497 fail(runString); | |
17498 return; | |
17499 } | |
17500 // (4) == true | |
17501 runString = "(4)"; | |
17502 if (true != jtt.lang.Int_lessEqual02.test(4)) { | |
17503 fail(runString); | |
17504 return; | |
17505 } | |
17506 // (5) == true | |
17507 runString = "(5)"; | |
17508 if (true != jtt.lang.Int_lessEqual02.test(5)) { | |
17509 fail(runString); | |
17510 return; | |
17511 } | |
17512 // (6) == false | |
17513 runString = "(6)"; | |
17514 if (false != jtt.lang.Int_lessEqual02.test(6)) { | |
17515 fail(runString); | |
17516 return; | |
17517 } | |
17518 // (2147483647) == false | |
17519 runString = "(2147483647)"; | |
17520 if (false != jtt.lang.Int_lessEqual02.test(2147483647)) { | |
17521 fail(runString); | |
17522 return; | |
17523 } | |
17524 } catch (Throwable t) { | |
17525 fail(runString, t); | |
17526 return; | |
17527 } | |
17528 pass(); | |
17529 } | |
17530 | |
17531 static void jtt_lang_Int_lessEqual03() { | |
17532 begin("jtt.lang.Int_lessEqual03"); | |
17533 String runString = null; | |
17534 try { | |
17535 // (-2147483648) == true | |
17536 runString = "(-2147483648)"; | |
17537 if (true != jtt.lang.Int_lessEqual03.test(-2147483648)) { | |
17538 fail(runString); | |
17539 return; | |
17540 } | |
17541 // (-6) == true | |
17542 runString = "(-6)"; | |
17543 if (true != jtt.lang.Int_lessEqual03.test(-6)) { | |
17544 fail(runString); | |
17545 return; | |
17546 } | |
17547 // (-5) == true | |
17548 runString = "(-5)"; | |
17549 if (true != jtt.lang.Int_lessEqual03.test(-5)) { | |
17550 fail(runString); | |
17551 return; | |
17552 } | |
17553 // (-4) == false | |
17554 runString = "(-4)"; | |
17555 if (false != jtt.lang.Int_lessEqual03.test(-4)) { | |
17556 fail(runString); | |
17557 return; | |
17558 } | |
17559 // (-1) == false | |
17560 runString = "(-1)"; | |
17561 if (false != jtt.lang.Int_lessEqual03.test(-1)) { | |
17562 fail(runString); | |
17563 return; | |
17564 } | |
17565 // (0) == false | |
17566 runString = "(0)"; | |
17567 if (false != jtt.lang.Int_lessEqual03.test(0)) { | |
17568 fail(runString); | |
17569 return; | |
17570 } | |
17571 // (1) == false | |
17572 runString = "(1)"; | |
17573 if (false != jtt.lang.Int_lessEqual03.test(1)) { | |
17574 fail(runString); | |
17575 return; | |
17576 } | |
17577 // (2) == false | |
17578 runString = "(2)"; | |
17579 if (false != jtt.lang.Int_lessEqual03.test(2)) { | |
17580 fail(runString); | |
17581 return; | |
17582 } | |
17583 // (2147483647) == false | |
17584 runString = "(2147483647)"; | |
17585 if (false != jtt.lang.Int_lessEqual03.test(2147483647)) { | |
17586 fail(runString); | |
17587 return; | |
17588 } | |
17589 } catch (Throwable t) { | |
17590 fail(runString, t); | |
17591 return; | |
17592 } | |
17593 pass(); | |
17594 } | |
17595 | |
17596 static void jtt_lang_JDK_ClassLoaders01() { | |
17597 begin("jtt.lang.JDK_ClassLoaders01"); | |
17598 String runString = null; | |
17599 try { | |
17600 // (0) == true | |
17601 runString = "(0)"; | |
17602 if (true != jtt.lang.JDK_ClassLoaders01.test(0)) { | |
17603 fail(runString); | |
17604 return; | |
17605 } | |
17606 // (1) == true | |
17607 runString = "(1)"; | |
17608 if (true != jtt.lang.JDK_ClassLoaders01.test(1)) { | |
17609 fail(runString); | |
17610 return; | |
17611 } | |
17612 // (2) == true | |
17613 runString = "(2)"; | |
17614 if (true != jtt.lang.JDK_ClassLoaders01.test(2)) { | |
17615 fail(runString); | |
17616 return; | |
17617 } | |
17618 // (3) == true | |
17619 runString = "(3)"; | |
17620 if (true != jtt.lang.JDK_ClassLoaders01.test(3)) { | |
17621 fail(runString); | |
17622 return; | |
17623 } | |
17624 // (4) == true | |
17625 runString = "(4)"; | |
17626 if (true != jtt.lang.JDK_ClassLoaders01.test(4)) { | |
17627 fail(runString); | |
17628 return; | |
17629 } | |
17630 // (5) == true | |
17631 runString = "(5)"; | |
17632 if (true != jtt.lang.JDK_ClassLoaders01.test(5)) { | |
17633 fail(runString); | |
17634 return; | |
17635 } | |
17636 // (6) == false | |
17637 runString = "(6)"; | |
17638 if (false != jtt.lang.JDK_ClassLoaders01.test(6)) { | |
17639 fail(runString); | |
17640 return; | |
17641 } | |
17642 } catch (Throwable t) { | |
17643 fail(runString, t); | |
17644 return; | |
17645 } | |
17646 pass(); | |
17647 } | |
17648 | |
17649 static void jtt_lang_JDK_ClassLoaders02() { | |
17650 begin("jtt.lang.JDK_ClassLoaders02"); | |
17651 String runString = null; | |
17652 try { | |
17653 // (0) == true | |
17654 runString = "(0)"; | |
17655 if (true != jtt.lang.JDK_ClassLoaders02.test(0)) { | |
17656 fail(runString); | |
17657 return; | |
17658 } | |
17659 } catch (Throwable t) { | |
17660 fail(runString, t); | |
17661 return; | |
17662 } | |
17663 pass(); | |
17664 } | |
17665 | |
17666 static void jtt_lang_Long_greater01() { | |
17667 begin("jtt.lang.Long_greater01"); | |
17668 String runString = null; | |
17669 try { | |
17670 // (-9223372036854775808) == false | |
17671 runString = "(-9223372036854775808)"; | |
17672 if (false != jtt.lang.Long_greater01.test(-9223372036854775808L)) { | |
17673 fail(runString); | |
17674 return; | |
17675 } | |
17676 // (-2) == false | |
17677 runString = "(-2)"; | |
17678 if (false != jtt.lang.Long_greater01.test(-2L)) { | |
17679 fail(runString); | |
17680 return; | |
17681 } | |
17682 // (-1) == false | |
17683 runString = "(-1)"; | |
17684 if (false != jtt.lang.Long_greater01.test(-1L)) { | |
17685 fail(runString); | |
17686 return; | |
17687 } | |
17688 // (0) == false | |
17689 runString = "(0)"; | |
17690 if (false != jtt.lang.Long_greater01.test(0L)) { | |
17691 fail(runString); | |
17692 return; | |
17693 } | |
17694 // (1) == true | |
17695 runString = "(1)"; | |
17696 if (true != jtt.lang.Long_greater01.test(1L)) { | |
17697 fail(runString); | |
17698 return; | |
17699 } | |
17700 // (2) == true | |
17701 runString = "(2)"; | |
17702 if (true != jtt.lang.Long_greater01.test(2L)) { | |
17703 fail(runString); | |
17704 return; | |
17705 } | |
17706 // (9223372036854775807) == true | |
17707 runString = "(9223372036854775807)"; | |
17708 if (true != jtt.lang.Long_greater01.test(9223372036854775807L)) { | |
17709 fail(runString); | |
17710 return; | |
17711 } | |
17712 } catch (Throwable t) { | |
17713 fail(runString, t); | |
17714 return; | |
17715 } | |
17716 pass(); | |
17717 } | |
17718 | |
17719 static void jtt_lang_Long_greater02() { | |
17720 begin("jtt.lang.Long_greater02"); | |
17721 String runString = null; | |
17722 try { | |
17723 // (-9223372036854775808) == false | |
17724 runString = "(-9223372036854775808)"; | |
17725 if (false != jtt.lang.Long_greater02.test(-9223372036854775808L)) { | |
17726 fail(runString); | |
17727 return; | |
17728 } | |
17729 // (-2) == false | |
17730 runString = "(-2)"; | |
17731 if (false != jtt.lang.Long_greater02.test(-2L)) { | |
17732 fail(runString); | |
17733 return; | |
17734 } | |
17735 // (-1) == false | |
17736 runString = "(-1)"; | |
17737 if (false != jtt.lang.Long_greater02.test(-1L)) { | |
17738 fail(runString); | |
17739 return; | |
17740 } | |
17741 // (0) == false | |
17742 runString = "(0)"; | |
17743 if (false != jtt.lang.Long_greater02.test(0L)) { | |
17744 fail(runString); | |
17745 return; | |
17746 } | |
17747 // (1) == false | |
17748 runString = "(1)"; | |
17749 if (false != jtt.lang.Long_greater02.test(1L)) { | |
17750 fail(runString); | |
17751 return; | |
17752 } | |
17753 // (4) == false | |
17754 runString = "(4)"; | |
17755 if (false != jtt.lang.Long_greater02.test(4L)) { | |
17756 fail(runString); | |
17757 return; | |
17758 } | |
17759 // (5) == false | |
17760 runString = "(5)"; | |
17761 if (false != jtt.lang.Long_greater02.test(5L)) { | |
17762 fail(runString); | |
17763 return; | |
17764 } | |
17765 // (6) == true | |
17766 runString = "(6)"; | |
17767 if (true != jtt.lang.Long_greater02.test(6L)) { | |
17768 fail(runString); | |
17769 return; | |
17770 } | |
17771 // (9223372036854775807) == true | |
17772 runString = "(9223372036854775807)"; | |
17773 if (true != jtt.lang.Long_greater02.test(9223372036854775807L)) { | |
17774 fail(runString); | |
17775 return; | |
17776 } | |
17777 } catch (Throwable t) { | |
17778 fail(runString, t); | |
17779 return; | |
17780 } | |
17781 pass(); | |
17782 } | |
17783 | |
17784 static void jtt_lang_Long_greater03() { | |
17785 begin("jtt.lang.Long_greater03"); | |
17786 String runString = null; | |
17787 try { | |
17788 // (-9223372036854775808) == false | |
17789 runString = "(-9223372036854775808)"; | |
17790 if (false != jtt.lang.Long_greater03.test(-9223372036854775808L)) { | |
17791 fail(runString); | |
17792 return; | |
17793 } | |
17794 // (-6) == false | |
17795 runString = "(-6)"; | |
17796 if (false != jtt.lang.Long_greater03.test(-6L)) { | |
17797 fail(runString); | |
17798 return; | |
17799 } | |
17800 // (-5) == false | |
17801 runString = "(-5)"; | |
17802 if (false != jtt.lang.Long_greater03.test(-5L)) { | |
17803 fail(runString); | |
17804 return; | |
17805 } | |
17806 // (-4) == true | |
17807 runString = "(-4)"; | |
17808 if (true != jtt.lang.Long_greater03.test(-4L)) { | |
17809 fail(runString); | |
17810 return; | |
17811 } | |
17812 // (-1) == true | |
17813 runString = "(-1)"; | |
17814 if (true != jtt.lang.Long_greater03.test(-1L)) { | |
17815 fail(runString); | |
17816 return; | |
17817 } | |
17818 // (0) == true | |
17819 runString = "(0)"; | |
17820 if (true != jtt.lang.Long_greater03.test(0L)) { | |
17821 fail(runString); | |
17822 return; | |
17823 } | |
17824 // (1) == true | |
17825 runString = "(1)"; | |
17826 if (true != jtt.lang.Long_greater03.test(1L)) { | |
17827 fail(runString); | |
17828 return; | |
17829 } | |
17830 // (2) == true | |
17831 runString = "(2)"; | |
17832 if (true != jtt.lang.Long_greater03.test(2L)) { | |
17833 fail(runString); | |
17834 return; | |
17835 } | |
17836 // (9223372036854775807) == true | |
17837 runString = "(9223372036854775807)"; | |
17838 if (true != jtt.lang.Long_greater03.test(9223372036854775807L)) { | |
17839 fail(runString); | |
17840 return; | |
17841 } | |
17842 } catch (Throwable t) { | |
17843 fail(runString, t); | |
17844 return; | |
17845 } | |
17846 pass(); | |
17847 } | |
17848 | |
17849 static void jtt_lang_Long_greaterEqual01() { | |
17850 begin("jtt.lang.Long_greaterEqual01"); | |
17851 String runString = null; | |
17852 try { | |
17853 // (-9223372036854775808) == false | |
17854 runString = "(-9223372036854775808)"; | |
17855 if (false != jtt.lang.Long_greaterEqual01 | |
17856 .test(-9223372036854775808L)) { | |
17857 fail(runString); | |
17858 return; | |
17859 } | |
17860 // (-2) == false | |
17861 runString = "(-2)"; | |
17862 if (false != jtt.lang.Long_greaterEqual01.test(-2L)) { | |
17863 fail(runString); | |
17864 return; | |
17865 } | |
17866 // (-1) == false | |
17867 runString = "(-1)"; | |
17868 if (false != jtt.lang.Long_greaterEqual01.test(-1L)) { | |
17869 fail(runString); | |
17870 return; | |
17871 } | |
17872 // (0) == true | |
17873 runString = "(0)"; | |
17874 if (true != jtt.lang.Long_greaterEqual01.test(0L)) { | |
17875 fail(runString); | |
17876 return; | |
17877 } | |
17878 // (1) == true | |
17879 runString = "(1)"; | |
17880 if (true != jtt.lang.Long_greaterEqual01.test(1L)) { | |
17881 fail(runString); | |
17882 return; | |
17883 } | |
17884 // (2) == true | |
17885 runString = "(2)"; | |
17886 if (true != jtt.lang.Long_greaterEqual01.test(2L)) { | |
17887 fail(runString); | |
17888 return; | |
17889 } | |
17890 // (9223372036854775807) == true | |
17891 runString = "(9223372036854775807)"; | |
17892 if (true != jtt.lang.Long_greaterEqual01.test(9223372036854775807L)) { | |
17893 fail(runString); | |
17894 return; | |
17895 } | |
17896 } catch (Throwable t) { | |
17897 fail(runString, t); | |
17898 return; | |
17899 } | |
17900 pass(); | |
17901 } | |
17902 | |
17903 static void jtt_lang_Long_greaterEqual02() { | |
17904 begin("jtt.lang.Long_greaterEqual02"); | |
17905 String runString = null; | |
17906 try { | |
17907 // (-9223372036854775808) == false | |
17908 runString = "(-9223372036854775808)"; | |
17909 if (false != jtt.lang.Long_greaterEqual02 | |
17910 .test(-9223372036854775808L)) { | |
17911 fail(runString); | |
17912 return; | |
17913 } | |
17914 // (-2) == false | |
17915 runString = "(-2)"; | |
17916 if (false != jtt.lang.Long_greaterEqual02.test(-2L)) { | |
17917 fail(runString); | |
17918 return; | |
17919 } | |
17920 // (-1) == false | |
17921 runString = "(-1)"; | |
17922 if (false != jtt.lang.Long_greaterEqual02.test(-1L)) { | |
17923 fail(runString); | |
17924 return; | |
17925 } | |
17926 // (0) == false | |
17927 runString = "(0)"; | |
17928 if (false != jtt.lang.Long_greaterEqual02.test(0L)) { | |
17929 fail(runString); | |
17930 return; | |
17931 } | |
17932 // (1) == false | |
17933 runString = "(1)"; | |
17934 if (false != jtt.lang.Long_greaterEqual02.test(1L)) { | |
17935 fail(runString); | |
17936 return; | |
17937 } | |
17938 // (4) == false | |
17939 runString = "(4)"; | |
17940 if (false != jtt.lang.Long_greaterEqual02.test(4L)) { | |
17941 fail(runString); | |
17942 return; | |
17943 } | |
17944 // (5) == true | |
17945 runString = "(5)"; | |
17946 if (true != jtt.lang.Long_greaterEqual02.test(5L)) { | |
17947 fail(runString); | |
17948 return; | |
17949 } | |
17950 // (6) == true | |
17951 runString = "(6)"; | |
17952 if (true != jtt.lang.Long_greaterEqual02.test(6L)) { | |
17953 fail(runString); | |
17954 return; | |
17955 } | |
17956 // (9223372036854775807) == true | |
17957 runString = "(9223372036854775807)"; | |
17958 if (true != jtt.lang.Long_greaterEqual02.test(9223372036854775807L)) { | |
17959 fail(runString); | |
17960 return; | |
17961 } | |
17962 } catch (Throwable t) { | |
17963 fail(runString, t); | |
17964 return; | |
17965 } | |
17966 pass(); | |
17967 } | |
17968 | |
17969 static void jtt_lang_Long_greaterEqual03() { | |
17970 begin("jtt.lang.Long_greaterEqual03"); | |
17971 String runString = null; | |
17972 try { | |
17973 // (-9223372036854775808) == false | |
17974 runString = "(-9223372036854775808)"; | |
17975 if (false != jtt.lang.Long_greaterEqual03 | |
17976 .test(-9223372036854775808L)) { | |
17977 fail(runString); | |
17978 return; | |
17979 } | |
17980 // (-6) == false | |
17981 runString = "(-6)"; | |
17982 if (false != jtt.lang.Long_greaterEqual03.test(-6L)) { | |
17983 fail(runString); | |
17984 return; | |
17985 } | |
17986 // (-5) == true | |
17987 runString = "(-5)"; | |
17988 if (true != jtt.lang.Long_greaterEqual03.test(-5L)) { | |
17989 fail(runString); | |
17990 return; | |
17991 } | |
17992 // (-4) == true | |
17993 runString = "(-4)"; | |
17994 if (true != jtt.lang.Long_greaterEqual03.test(-4L)) { | |
17995 fail(runString); | |
17996 return; | |
17997 } | |
17998 // (-1) == true | |
17999 runString = "(-1)"; | |
18000 if (true != jtt.lang.Long_greaterEqual03.test(-1L)) { | |
18001 fail(runString); | |
18002 return; | |
18003 } | |
18004 // (0) == true | |
18005 runString = "(0)"; | |
18006 if (true != jtt.lang.Long_greaterEqual03.test(0L)) { | |
18007 fail(runString); | |
18008 return; | |
18009 } | |
18010 // (1) == true | |
18011 runString = "(1)"; | |
18012 if (true != jtt.lang.Long_greaterEqual03.test(1L)) { | |
18013 fail(runString); | |
18014 return; | |
18015 } | |
18016 // (2) == true | |
18017 runString = "(2)"; | |
18018 if (true != jtt.lang.Long_greaterEqual03.test(2L)) { | |
18019 fail(runString); | |
18020 return; | |
18021 } | |
18022 // (9223372036854775807) == true | |
18023 runString = "(9223372036854775807)"; | |
18024 if (true != jtt.lang.Long_greaterEqual03.test(9223372036854775807L)) { | |
18025 fail(runString); | |
18026 return; | |
18027 } | |
18028 } catch (Throwable t) { | |
18029 fail(runString, t); | |
18030 return; | |
18031 } | |
18032 pass(); | |
18033 } | |
18034 | |
18035 static void jtt_lang_Long_less01() { | |
18036 begin("jtt.lang.Long_less01"); | |
18037 String runString = null; | |
18038 try { | |
18039 // (-9223372036854775808) == true | |
18040 runString = "(-9223372036854775808)"; | |
18041 if (true != jtt.lang.Long_less01.test(-9223372036854775808L)) { | |
18042 fail(runString); | |
18043 return; | |
18044 } | |
18045 // (-2) == true | |
18046 runString = "(-2)"; | |
18047 if (true != jtt.lang.Long_less01.test(-2L)) { | |
18048 fail(runString); | |
18049 return; | |
18050 } | |
18051 // (-1) == true | |
18052 runString = "(-1)"; | |
18053 if (true != jtt.lang.Long_less01.test(-1L)) { | |
18054 fail(runString); | |
18055 return; | |
18056 } | |
18057 // (0) == false | |
18058 runString = "(0)"; | |
18059 if (false != jtt.lang.Long_less01.test(0L)) { | |
18060 fail(runString); | |
18061 return; | |
18062 } | |
18063 // (1) == false | |
18064 runString = "(1)"; | |
18065 if (false != jtt.lang.Long_less01.test(1L)) { | |
18066 fail(runString); | |
18067 return; | |
18068 } | |
18069 // (2) == false | |
18070 runString = "(2)"; | |
18071 if (false != jtt.lang.Long_less01.test(2L)) { | |
18072 fail(runString); | |
18073 return; | |
18074 } | |
18075 // (9223372036854775807) == false | |
18076 runString = "(9223372036854775807)"; | |
18077 if (false != jtt.lang.Long_less01.test(9223372036854775807L)) { | |
18078 fail(runString); | |
18079 return; | |
18080 } | |
18081 } catch (Throwable t) { | |
18082 fail(runString, t); | |
18083 return; | |
18084 } | |
18085 pass(); | |
18086 } | |
18087 | |
18088 static void jtt_lang_Long_less02() { | |
18089 begin("jtt.lang.Long_less02"); | |
18090 String runString = null; | |
18091 try { | |
18092 // (-9223372036854775808) == true | |
18093 runString = "(-9223372036854775808)"; | |
18094 if (true != jtt.lang.Long_less02.test(-9223372036854775808L)) { | |
18095 fail(runString); | |
18096 return; | |
18097 } | |
18098 // (-2) == true | |
18099 runString = "(-2)"; | |
18100 if (true != jtt.lang.Long_less02.test(-2L)) { | |
18101 fail(runString); | |
18102 return; | |
18103 } | |
18104 // (-1) == true | |
18105 runString = "(-1)"; | |
18106 if (true != jtt.lang.Long_less02.test(-1L)) { | |
18107 fail(runString); | |
18108 return; | |
18109 } | |
18110 // (0) == true | |
18111 runString = "(0)"; | |
18112 if (true != jtt.lang.Long_less02.test(0L)) { | |
18113 fail(runString); | |
18114 return; | |
18115 } | |
18116 // (4) == true | |
18117 runString = "(4)"; | |
18118 if (true != jtt.lang.Long_less02.test(4L)) { | |
18119 fail(runString); | |
18120 return; | |
18121 } | |
18122 // (5) == false | |
18123 runString = "(5)"; | |
18124 if (false != jtt.lang.Long_less02.test(5L)) { | |
18125 fail(runString); | |
18126 return; | |
18127 } | |
18128 // (6) == false | |
18129 runString = "(6)"; | |
18130 if (false != jtt.lang.Long_less02.test(6L)) { | |
18131 fail(runString); | |
18132 return; | |
18133 } | |
18134 // (9223372036854775807) == false | |
18135 runString = "(9223372036854775807)"; | |
18136 if (false != jtt.lang.Long_less02.test(9223372036854775807L)) { | |
18137 fail(runString); | |
18138 return; | |
18139 } | |
18140 } catch (Throwable t) { | |
18141 fail(runString, t); | |
18142 return; | |
18143 } | |
18144 pass(); | |
18145 } | |
18146 | |
18147 static void jtt_lang_Long_less03() { | |
18148 begin("jtt.lang.Long_less03"); | |
18149 String runString = null; | |
18150 try { | |
18151 // (-9223372036854775808) == true | |
18152 runString = "(-9223372036854775808)"; | |
18153 if (true != jtt.lang.Long_less03.test(-9223372036854775808L)) { | |
18154 fail(runString); | |
18155 return; | |
18156 } | |
18157 // (-6) == true | |
18158 runString = "(-6)"; | |
18159 if (true != jtt.lang.Long_less03.test(-6L)) { | |
18160 fail(runString); | |
18161 return; | |
18162 } | |
18163 // (-5) == false | |
18164 runString = "(-5)"; | |
18165 if (false != jtt.lang.Long_less03.test(-5L)) { | |
18166 fail(runString); | |
18167 return; | |
18168 } | |
18169 // (-4) == false | |
18170 runString = "(-4)"; | |
18171 if (false != jtt.lang.Long_less03.test(-4L)) { | |
18172 fail(runString); | |
18173 return; | |
18174 } | |
18175 // (-1) == false | |
18176 runString = "(-1)"; | |
18177 if (false != jtt.lang.Long_less03.test(-1L)) { | |
18178 fail(runString); | |
18179 return; | |
18180 } | |
18181 // (0) == false | |
18182 runString = "(0)"; | |
18183 if (false != jtt.lang.Long_less03.test(0L)) { | |
18184 fail(runString); | |
18185 return; | |
18186 } | |
18187 // (1) == false | |
18188 runString = "(1)"; | |
18189 if (false != jtt.lang.Long_less03.test(1L)) { | |
18190 fail(runString); | |
18191 return; | |
18192 } | |
18193 // (2) == false | |
18194 runString = "(2)"; | |
18195 if (false != jtt.lang.Long_less03.test(2L)) { | |
18196 fail(runString); | |
18197 return; | |
18198 } | |
18199 // (9223372036854775807) == false | |
18200 runString = "(9223372036854775807)"; | |
18201 if (false != jtt.lang.Long_less03.test(9223372036854775807L)) { | |
18202 fail(runString); | |
18203 return; | |
18204 } | |
18205 } catch (Throwable t) { | |
18206 fail(runString, t); | |
18207 return; | |
18208 } | |
18209 pass(); | |
18210 } | |
18211 | |
18212 static void jtt_lang_Long_lessEqual01() { | |
18213 begin("jtt.lang.Long_lessEqual01"); | |
18214 String runString = null; | |
18215 try { | |
18216 // (-2) == true | |
18217 runString = "(-2)"; | |
18218 if (true != jtt.lang.Long_lessEqual01.test(-2L)) { | |
18219 fail(runString); | |
18220 return; | |
18221 } | |
18222 // (-9223372036854775808) == true | |
18223 runString = "(-9223372036854775808)"; | |
18224 if (true != jtt.lang.Long_lessEqual01.test(-9223372036854775808L)) { | |
18225 fail(runString); | |
18226 return; | |
18227 } | |
18228 // (-2) == true | |
18229 runString = "(-2)"; | |
18230 if (true != jtt.lang.Long_lessEqual01.test(-2L)) { | |
18231 fail(runString); | |
18232 return; | |
18233 } | |
18234 // (-1) == true | |
18235 runString = "(-1)"; | |
18236 if (true != jtt.lang.Long_lessEqual01.test(-1L)) { | |
18237 fail(runString); | |
18238 return; | |
18239 } | |
18240 // (0) == true | |
18241 runString = "(0)"; | |
18242 if (true != jtt.lang.Long_lessEqual01.test(0L)) { | |
18243 fail(runString); | |
18244 return; | |
18245 } | |
18246 // (1) == false | |
18247 runString = "(1)"; | |
18248 if (false != jtt.lang.Long_lessEqual01.test(1L)) { | |
18249 fail(runString); | |
18250 return; | |
18251 } | |
18252 // (2) == false | |
18253 runString = "(2)"; | |
18254 if (false != jtt.lang.Long_lessEqual01.test(2L)) { | |
18255 fail(runString); | |
18256 return; | |
18257 } | |
18258 // (9223372036854775807) == false | |
18259 runString = "(9223372036854775807)"; | |
18260 if (false != jtt.lang.Long_lessEqual01.test(9223372036854775807L)) { | |
18261 fail(runString); | |
18262 return; | |
18263 } | |
18264 } catch (Throwable t) { | |
18265 fail(runString, t); | |
18266 return; | |
18267 } | |
18268 pass(); | |
18269 } | |
18270 | |
18271 static void jtt_lang_Long_lessEqual02() { | |
18272 begin("jtt.lang.Long_lessEqual02"); | |
18273 String runString = null; | |
18274 try { | |
18275 // (-9223372036854775808) == true | |
18276 runString = "(-9223372036854775808)"; | |
18277 if (true != jtt.lang.Long_lessEqual02.test(-9223372036854775808L)) { | |
18278 fail(runString); | |
18279 return; | |
18280 } | |
18281 // (-2) == true | |
18282 runString = "(-2)"; | |
18283 if (true != jtt.lang.Long_lessEqual02.test(-2L)) { | |
18284 fail(runString); | |
18285 return; | |
18286 } | |
18287 // (-1) == true | |
18288 runString = "(-1)"; | |
18289 if (true != jtt.lang.Long_lessEqual02.test(-1L)) { | |
18290 fail(runString); | |
18291 return; | |
18292 } | |
18293 // (0) == true | |
18294 runString = "(0)"; | |
18295 if (true != jtt.lang.Long_lessEqual02.test(0L)) { | |
18296 fail(runString); | |
18297 return; | |
18298 } | |
18299 // (4) == true | |
18300 runString = "(4)"; | |
18301 if (true != jtt.lang.Long_lessEqual02.test(4L)) { | |
18302 fail(runString); | |
18303 return; | |
18304 } | |
18305 // (5) == true | |
18306 runString = "(5)"; | |
18307 if (true != jtt.lang.Long_lessEqual02.test(5L)) { | |
18308 fail(runString); | |
18309 return; | |
18310 } | |
18311 // (6) == false | |
18312 runString = "(6)"; | |
18313 if (false != jtt.lang.Long_lessEqual02.test(6L)) { | |
18314 fail(runString); | |
18315 return; | |
18316 } | |
18317 // (9223372036854775807) == false | |
18318 runString = "(9223372036854775807)"; | |
18319 if (false != jtt.lang.Long_lessEqual02.test(9223372036854775807L)) { | |
18320 fail(runString); | |
18321 return; | |
18322 } | |
18323 } catch (Throwable t) { | |
18324 fail(runString, t); | |
18325 return; | |
18326 } | |
18327 pass(); | |
18328 } | |
18329 | |
18330 static void jtt_lang_Long_lessEqual03() { | |
18331 begin("jtt.lang.Long_lessEqual03"); | |
18332 String runString = null; | |
18333 try { | |
18334 // (-9223372036854775808) == true | |
18335 runString = "(-9223372036854775808)"; | |
18336 if (true != jtt.lang.Long_lessEqual03.test(-9223372036854775808L)) { | |
18337 fail(runString); | |
18338 return; | |
18339 } | |
18340 // (-6) == true | |
18341 runString = "(-6)"; | |
18342 if (true != jtt.lang.Long_lessEqual03.test(-6L)) { | |
18343 fail(runString); | |
18344 return; | |
18345 } | |
18346 // (-5) == true | |
18347 runString = "(-5)"; | |
18348 if (true != jtt.lang.Long_lessEqual03.test(-5L)) { | |
18349 fail(runString); | |
18350 return; | |
18351 } | |
18352 // (-4) == false | |
18353 runString = "(-4)"; | |
18354 if (false != jtt.lang.Long_lessEqual03.test(-4L)) { | |
18355 fail(runString); | |
18356 return; | |
18357 } | |
18358 // (-1) == false | |
18359 runString = "(-1)"; | |
18360 if (false != jtt.lang.Long_lessEqual03.test(-1L)) { | |
18361 fail(runString); | |
18362 return; | |
18363 } | |
18364 // (0) == false | |
18365 runString = "(0)"; | |
18366 if (false != jtt.lang.Long_lessEqual03.test(0L)) { | |
18367 fail(runString); | |
18368 return; | |
18369 } | |
18370 // (1) == false | |
18371 runString = "(1)"; | |
18372 if (false != jtt.lang.Long_lessEqual03.test(1L)) { | |
18373 fail(runString); | |
18374 return; | |
18375 } | |
18376 // (2) == false | |
18377 runString = "(2)"; | |
18378 if (false != jtt.lang.Long_lessEqual03.test(2L)) { | |
18379 fail(runString); | |
18380 return; | |
18381 } | |
18382 // (9223372036854775807) == false | |
18383 runString = "(9223372036854775807)"; | |
18384 if (false != jtt.lang.Long_lessEqual03.test(9223372036854775807L)) { | |
18385 fail(runString); | |
18386 return; | |
18387 } | |
18388 } catch (Throwable t) { | |
18389 fail(runString, t); | |
18390 return; | |
18391 } | |
18392 pass(); | |
18393 } | |
18394 | |
18395 static void jtt_lang_Long_reverseBytes01() { | |
18396 begin("jtt.lang.Long_reverseBytes01"); | |
18397 String runString = null; | |
18398 try { | |
18399 // (1234605616436508424) == 610068790934446609 | |
18400 runString = "(1234605616436508424)"; | |
18401 if (610068790934446609L != jtt.lang.Long_reverseBytes01 | |
18402 .test(1234605616436508424L)) { | |
18403 fail(runString); | |
18404 return; | |
18405 } | |
18406 } catch (Throwable t) { | |
18407 fail(runString, t); | |
18408 return; | |
18409 } | |
18410 pass(); | |
18411 } | |
18412 | |
18413 static void jtt_lang_Long_reverseBytes02() { | |
18414 begin("jtt.lang.Long_reverseBytes02"); | |
18415 String runString = null; | |
18416 try { | |
18417 // (1234605616436508424) == 610068790934446609 | |
18418 runString = "(1234605616436508424)"; | |
18419 if (610068790934446609L != jtt.lang.Long_reverseBytes02 | |
18420 .test(1234605616436508424L)) { | |
18421 fail(runString); | |
18422 return; | |
18423 } | |
18424 } catch (Throwable t) { | |
18425 fail(runString, t); | |
18426 return; | |
18427 } | |
18428 pass(); | |
18429 } | |
18430 | |
18431 static void jtt_lang_Math_pow() { | |
18432 begin("jtt.lang.Math_pow"); | |
18433 String runString = null; | |
18434 try { | |
18435 // (2.0) == 4.0 | |
18436 runString = "(2.0)"; | |
18437 if (4.0 != jtt.lang.Math_pow.test(2.0)) { | |
18438 fail(runString); | |
18439 return; | |
18440 } | |
18441 // (3.1) == 8.574187700290345 | |
18442 runString = "(3.1)"; | |
18443 if (8.574187700290345 != jtt.lang.Math_pow.test(3.1)) { | |
18444 fail(runString); | |
18445 return; | |
18446 } | |
18447 } catch (Throwable t) { | |
18448 fail(runString, t); | |
18449 return; | |
18450 } | |
18451 pass(); | |
18452 } | |
18453 | |
18454 static void jtt_lang_Object_clone01() { | |
18455 begin("jtt.lang.Object_clone01"); | |
18456 String runString = null; | |
18457 try { | |
18458 // (0) == !java.lang.CloneNotSupportedException | |
18459 try { | |
18460 runString = "(0)"; | |
18461 jtt.lang.Object_clone01.test(0); | |
18462 fail(runString); | |
18463 return; | |
18464 } catch (Throwable e) { | |
18465 if (e.getClass() != java.lang.CloneNotSupportedException.class) { | |
18466 fail(runString, e); | |
18467 return; | |
18468 } | |
18469 } | |
18470 } catch (Throwable t) { | |
18471 fail(runString, t); | |
18472 return; | |
18473 } | |
18474 pass(); | |
18475 } | |
18476 | |
18477 static void jtt_lang_Object_clone02() { | |
18478 begin("jtt.lang.Object_clone02"); | |
18479 String runString = null; | |
18480 try { | |
18481 // (0) == false | |
18482 runString = "(0)"; | |
18483 if (false != jtt.lang.Object_clone02.test(0)) { | |
18484 fail(runString); | |
18485 return; | |
18486 } | |
18487 } catch (Throwable t) { | |
18488 fail(runString, t); | |
18489 return; | |
18490 } | |
18491 pass(); | |
18492 } | |
18493 | |
18494 static void jtt_lang_Object_equals01() { | |
18495 begin("jtt.lang.Object_equals01"); | |
18496 String runString = null; | |
18497 try { | |
18498 // (0) == false | |
18499 runString = "(0)"; | |
18500 if (false != jtt.lang.Object_equals01.test(0)) { | |
18501 fail(runString); | |
18502 return; | |
18503 } | |
18504 // (1) == false | |
18505 runString = "(1)"; | |
18506 if (false != jtt.lang.Object_equals01.test(1)) { | |
18507 fail(runString); | |
18508 return; | |
18509 } | |
18510 // (2) == false | |
18511 runString = "(2)"; | |
18512 if (false != jtt.lang.Object_equals01.test(2)) { | |
18513 fail(runString); | |
18514 return; | |
18515 } | |
18516 // (3) == true | |
18517 runString = "(3)"; | |
18518 if (true != jtt.lang.Object_equals01.test(3)) { | |
18519 fail(runString); | |
18520 return; | |
18521 } | |
18522 // (4) == true | |
18523 runString = "(4)"; | |
18524 if (true != jtt.lang.Object_equals01.test(4)) { | |
18525 fail(runString); | |
18526 return; | |
18527 } | |
18528 // (5) == false | |
18529 runString = "(5)"; | |
18530 if (false != jtt.lang.Object_equals01.test(5)) { | |
18531 fail(runString); | |
18532 return; | |
18533 } | |
18534 // (6) == true | |
18535 runString = "(6)"; | |
18536 if (true != jtt.lang.Object_equals01.test(6)) { | |
18537 fail(runString); | |
18538 return; | |
18539 } | |
18540 // (7) == false | |
18541 runString = "(7)"; | |
18542 if (false != jtt.lang.Object_equals01.test(7)) { | |
18543 fail(runString); | |
18544 return; | |
18545 } | |
18546 // (8) == false | |
18547 runString = "(8)"; | |
18548 if (false != jtt.lang.Object_equals01.test(8)) { | |
18549 fail(runString); | |
18550 return; | |
18551 } | |
18552 } catch (Throwable t) { | |
18553 fail(runString, t); | |
18554 return; | |
18555 } | |
18556 pass(); | |
18557 } | |
18558 | |
18559 static void jtt_lang_Object_getClass01() { | |
18560 begin("jtt.lang.Object_getClass01"); | |
18561 String runString = null; | |
18562 try { | |
18563 // (0) == "class java.lang.Object" | |
18564 runString = "(0)"; | |
18565 if (!"class java.lang.Object".equals(jtt.lang.Object_getClass01 | |
18566 .test(0))) { | |
18567 fail(runString); | |
18568 return; | |
18569 } | |
18570 // (1) == "class java.lang.String" | |
18571 runString = "(1)"; | |
18572 if (!"class java.lang.String".equals(jtt.lang.Object_getClass01 | |
18573 .test(1))) { | |
18574 fail(runString); | |
18575 return; | |
18576 } | |
18577 // (2) == "class jtt.lang.Object_getClass01" | |
18578 runString = "(2)"; | |
18579 if (!"class jtt.lang.Object_getClass01" | |
18580 .equals(jtt.lang.Object_getClass01.test(2))) { | |
18581 fail(runString); | |
18582 return; | |
18583 } | |
18584 } catch (Throwable t) { | |
18585 fail(runString, t); | |
18586 return; | |
18587 } | |
18588 pass(); | |
18589 } | |
18590 | |
18591 static void jtt_lang_Object_hashCode01() { | |
18592 begin("jtt.lang.Object_hashCode01"); | |
18593 String runString = null; | |
18594 try { | |
18595 // (0) == true | |
18596 runString = "(0)"; | |
18597 if (true != jtt.lang.Object_hashCode01.test(0)) { | |
18598 fail(runString); | |
18599 return; | |
18600 } | |
18601 } catch (Throwable t) { | |
18602 fail(runString, t); | |
18603 return; | |
18604 } | |
18605 pass(); | |
18606 } | |
18607 | |
18608 static void jtt_lang_Object_notify01() { | |
18609 begin("jtt.lang.Object_notify01"); | |
18610 String runString = null; | |
18611 try { | |
18612 // (0) == !java.lang.IllegalMonitorStateException | |
18613 try { | |
18614 runString = "(0)"; | |
18615 jtt.lang.Object_notify01.test(0); | |
18616 fail(runString); | |
18617 return; | |
18618 } catch (Throwable e) { | |
18619 if (e.getClass() != java.lang.IllegalMonitorStateException.class) { | |
18620 fail(runString, e); | |
18621 return; | |
18622 } | |
18623 } | |
18624 } catch (Throwable t) { | |
18625 fail(runString, t); | |
18626 return; | |
18627 } | |
18628 pass(); | |
18629 } | |
18630 | |
18631 static void jtt_lang_Object_notify02() { | |
18632 begin("jtt.lang.Object_notify02"); | |
18633 String runString = null; | |
18634 try { | |
18635 // (0) == true | |
18636 runString = "(0)"; | |
18637 if (true != jtt.lang.Object_notify02.test(0)) { | |
18638 fail(runString); | |
18639 return; | |
18640 } | |
18641 } catch (Throwable t) { | |
18642 fail(runString, t); | |
18643 return; | |
18644 } | |
18645 pass(); | |
18646 } | |
18647 | |
18648 static void jtt_lang_Object_notifyAll01() { | |
18649 begin("jtt.lang.Object_notifyAll01"); | |
18650 String runString = null; | |
18651 try { | |
18652 // (0) == !java.lang.IllegalMonitorStateException | |
18653 try { | |
18654 runString = "(0)"; | |
18655 jtt.lang.Object_notifyAll01.test(0); | |
18656 fail(runString); | |
18657 return; | |
18658 } catch (Throwable e) { | |
18659 if (e.getClass() != java.lang.IllegalMonitorStateException.class) { | |
18660 fail(runString, e); | |
18661 return; | |
18662 } | |
18663 } | |
18664 } catch (Throwable t) { | |
18665 fail(runString, t); | |
18666 return; | |
18667 } | |
18668 pass(); | |
18669 } | |
18670 | |
18671 static void jtt_lang_Object_notifyAll02() { | |
18672 begin("jtt.lang.Object_notifyAll02"); | |
18673 String runString = null; | |
18674 try { | |
18675 // (0) == true | |
18676 runString = "(0)"; | |
18677 if (true != jtt.lang.Object_notifyAll02.test(0)) { | |
18678 fail(runString); | |
18679 return; | |
18680 } | |
18681 } catch (Throwable t) { | |
18682 fail(runString, t); | |
18683 return; | |
18684 } | |
18685 pass(); | |
18686 } | |
18687 | |
18688 static void jtt_lang_Object_toString01() { | |
18689 begin("jtt.lang.Object_toString01"); | |
18690 String runString = null; | |
18691 try { | |
18692 // (0) == true | |
18693 runString = "(0)"; | |
18694 if (true != jtt.lang.Object_toString01.test(0)) { | |
18695 fail(runString); | |
18696 return; | |
18697 } | |
18698 // (1) == true | |
18699 runString = "(1)"; | |
18700 if (true != jtt.lang.Object_toString01.test(1)) { | |
18701 fail(runString); | |
18702 return; | |
18703 } | |
18704 // (2) == false | |
18705 runString = "(2)"; | |
18706 if (false != jtt.lang.Object_toString01.test(2)) { | |
18707 fail(runString); | |
18708 return; | |
18709 } | |
18710 } catch (Throwable t) { | |
18711 fail(runString, t); | |
18712 return; | |
18713 } | |
18714 pass(); | |
18715 } | |
18716 | |
18717 static void jtt_lang_Object_toString02() { | |
18718 begin("jtt.lang.Object_toString02"); | |
18719 String runString = null; | |
18720 try { | |
18721 // (0) == "XYZ" | |
18722 runString = "(0)"; | |
18723 if (!"XYZ".equals(jtt.lang.Object_toString02.test(0))) { | |
18724 fail(runString); | |
18725 return; | |
18726 } | |
18727 // (1) == "string" | |
18728 runString = "(1)"; | |
18729 if (!"string".equals(jtt.lang.Object_toString02.test(1))) { | |
18730 fail(runString); | |
18731 return; | |
18732 } | |
18733 // (2) == "class java.lang.String" | |
18734 runString = "(2)"; | |
18735 if (!"class java.lang.String".equals(jtt.lang.Object_toString02 | |
18736 .test(2))) { | |
18737 fail(runString); | |
18738 return; | |
18739 } | |
18740 // (3) == !java.lang.NullPointerException | |
18741 try { | |
18742 runString = "(3)"; | |
18743 jtt.lang.Object_toString02.test(3); | |
18744 fail(runString); | |
18745 return; | |
18746 } catch (Throwable e) { | |
18747 if (e.getClass() != java.lang.NullPointerException.class) { | |
18748 fail(runString, e); | |
18749 return; | |
18750 } | |
18751 } | |
18752 } catch (Throwable t) { | |
18753 fail(runString, t); | |
18754 return; | |
18755 } | |
18756 pass(); | |
18757 } | |
18758 | |
18759 static void jtt_lang_Object_wait01() { | |
18760 begin("jtt.lang.Object_wait01"); | |
18761 String runString = null; | |
18762 try { | |
18763 // (0) == !java.lang.IllegalMonitorStateException | |
18764 try { | |
18765 runString = "(0)"; | |
18766 jtt.lang.Object_wait01.test(0); | |
18767 fail(runString); | |
18768 return; | |
18769 } catch (Throwable e) { | |
18770 if (e.getClass() != java.lang.IllegalMonitorStateException.class) { | |
18771 fail(runString, e); | |
18772 return; | |
18773 } | |
18774 } | |
18775 } catch (Throwable t) { | |
18776 fail(runString, t); | |
18777 return; | |
18778 } | |
18779 pass(); | |
18780 } | |
18781 | |
18782 static void jtt_lang_Object_wait02() { | |
18783 begin("jtt.lang.Object_wait02"); | |
18784 String runString = null; | |
18785 try { | |
18786 // (0) == true | |
18787 runString = "(0)"; | |
18788 if (true != jtt.lang.Object_wait02.test(0)) { | |
18789 fail(runString); | |
18790 return; | |
18791 } | |
18792 } catch (Throwable t) { | |
18793 fail(runString, t); | |
18794 return; | |
18795 } | |
18796 pass(); | |
18797 } | |
18798 | |
18799 static void jtt_lang_Object_wait03() { | |
18800 begin("jtt.lang.Object_wait03"); | |
18801 String runString = null; | |
18802 try { | |
18803 // (0) == true | |
18804 runString = "(0)"; | |
18805 if (true != jtt.lang.Object_wait03.test(0)) { | |
18806 fail(runString); | |
18807 return; | |
18808 } | |
18809 } catch (Throwable t) { | |
18810 fail(runString, t); | |
18811 return; | |
18812 } | |
18813 pass(); | |
18814 } | |
18815 | |
18816 static void jtt_lang_ProcessEnvironment_init() { | |
18817 begin("jtt.lang.ProcessEnvironment_init"); | |
18818 String runString = null; | |
18819 try { | |
18820 // (7) == 7 | |
18821 runString = "(7)"; | |
18822 if (7 != jtt.lang.ProcessEnvironment_init.test(7)) { | |
18823 fail(runString); | |
18824 return; | |
18825 } | |
18826 } catch (Throwable t) { | |
18827 fail(runString, t); | |
18828 return; | |
18829 } | |
18830 pass(); | |
18831 } | |
18832 | |
18833 static void jtt_lang_StringCoding_Scale() { | |
18834 begin("jtt.lang.StringCoding_Scale"); | |
18835 String runString = null; | |
18836 try { | |
18837 // (2) == 2 | |
18838 runString = "(2)"; | |
18839 if (2 != jtt.lang.StringCoding_Scale.test(2)) { | |
18840 fail(runString); | |
18841 return; | |
18842 } | |
18843 // (1) == 1 | |
18844 runString = "(1)"; | |
18845 if (1 != jtt.lang.StringCoding_Scale.test(1)) { | |
18846 fail(runString); | |
18847 return; | |
18848 } | |
18849 // (0) == 0 | |
18850 runString = "(0)"; | |
18851 if (0 != jtt.lang.StringCoding_Scale.test(0)) { | |
18852 fail(runString); | |
18853 return; | |
18854 } | |
18855 } catch (Throwable t) { | |
18856 fail(runString, t); | |
18857 return; | |
18858 } | |
18859 pass(); | |
18860 } | |
18861 | |
18862 static void jtt_lang_String_intern01() { | |
18863 begin("jtt.lang.String_intern01"); | |
18864 String runString = null; | |
18865 try { | |
18866 // (0) == true | |
18867 runString = "(0)"; | |
18868 if (true != jtt.lang.String_intern01.test(0)) { | |
18869 fail(runString); | |
18870 return; | |
18871 } | |
18872 } catch (Throwable t) { | |
18873 fail(runString, t); | |
18874 return; | |
18875 } | |
18876 pass(); | |
18877 } | |
18878 | |
18879 static void jtt_lang_String_intern02() { | |
18880 begin("jtt.lang.String_intern02"); | |
18881 String runString = null; | |
18882 try { | |
18883 // (0) == true | |
18884 runString = "(0)"; | |
18885 if (true != jtt.lang.String_intern02.test(0)) { | |
18886 fail(runString); | |
18887 return; | |
18888 } | |
18889 // (1) == true | |
18890 runString = "(1)"; | |
18891 if (true != jtt.lang.String_intern02.test(1)) { | |
18892 fail(runString); | |
18893 return; | |
18894 } | |
18895 // (2) == true | |
18896 runString = "(2)"; | |
18897 if (true != jtt.lang.String_intern02.test(2)) { | |
18898 fail(runString); | |
18899 return; | |
18900 } | |
18901 } catch (Throwable t) { | |
18902 fail(runString, t); | |
18903 return; | |
18904 } | |
18905 pass(); | |
18906 } | |
18907 | |
18908 static void jtt_lang_String_intern03() { | |
18909 begin("jtt.lang.String_intern03"); | |
18910 String runString = null; | |
18911 try { | |
18912 // (0) == true | |
18913 runString = "(0)"; | |
18914 if (true != jtt.lang.String_intern03.test(0)) { | |
18915 fail(runString); | |
18916 return; | |
18917 } | |
18918 // (1) == true | |
18919 runString = "(1)"; | |
18920 if (true != jtt.lang.String_intern03.test(1)) { | |
18921 fail(runString); | |
18922 return; | |
18923 } | |
18924 // (2) == true | |
18925 runString = "(2)"; | |
18926 if (true != jtt.lang.String_intern03.test(2)) { | |
18927 fail(runString); | |
18928 return; | |
18929 } | |
18930 } catch (Throwable t) { | |
18931 fail(runString, t); | |
18932 return; | |
18933 } | |
18934 pass(); | |
18935 } | |
18936 | |
18937 static void jtt_lang_String_valueOf01() { | |
18938 begin("jtt.lang.String_valueOf01"); | |
18939 String runString = null; | |
18940 try { | |
18941 // (0) == "null" | |
18942 runString = "(0)"; | |
18943 if (!"null".equals(jtt.lang.String_valueOf01.test(0))) { | |
18944 fail(runString); | |
18945 return; | |
18946 } | |
18947 // (1) == "string" | |
18948 runString = "(1)"; | |
18949 if (!"string".equals(jtt.lang.String_valueOf01.test(1))) { | |
18950 fail(runString); | |
18951 return; | |
18952 } | |
18953 } catch (Throwable t) { | |
18954 fail(runString, t); | |
18955 return; | |
18956 } | |
18957 pass(); | |
18958 } | |
18959 | |
18960 static void jtt_lang_System_identityHashCode01() { | |
18961 begin("jtt.lang.System_identityHashCode01"); | |
18962 String runString = null; | |
18963 try { | |
18964 // (0) == true | |
18965 runString = "(0)"; | |
18966 if (true != jtt.lang.System_identityHashCode01.test(0)) { | |
18967 fail(runString); | |
18968 return; | |
18969 } | |
18970 // (1) == true | |
18971 runString = "(1)"; | |
18972 if (true != jtt.lang.System_identityHashCode01.test(1)) { | |
18973 fail(runString); | |
18974 return; | |
18975 } | |
18976 // (2) == true | |
18977 runString = "(2)"; | |
18978 if (true != jtt.lang.System_identityHashCode01.test(2)) { | |
18979 fail(runString); | |
18980 return; | |
18981 } | |
18982 // (3) == false | |
18983 runString = "(3)"; | |
18984 if (false != jtt.lang.System_identityHashCode01.test(3)) { | |
18985 fail(runString); | |
18986 return; | |
18987 } | |
18988 } catch (Throwable t) { | |
18989 fail(runString, t); | |
18990 return; | |
18991 } | |
18992 pass(); | |
18993 } | |
18994 | |
18995 static void jtt_micro_ArrayCompare01() { | |
18996 begin("jtt.micro.ArrayCompare01"); | |
18997 String runString = null; | |
18998 try { | |
18999 // (0) == true | |
19000 runString = "(0)"; | |
19001 if (true != jtt.micro.ArrayCompare01.test(0)) { | |
19002 fail(runString); | |
19003 return; | |
19004 } | |
19005 // (1) == false | |
19006 runString = "(1)"; | |
19007 if (false != jtt.micro.ArrayCompare01.test(1)) { | |
19008 fail(runString); | |
19009 return; | |
19010 } | |
19011 } catch (Throwable t) { | |
19012 fail(runString, t); | |
19013 return; | |
19014 } | |
19015 pass(); | |
19016 } | |
19017 | |
19018 static void jtt_micro_ArrayCompare02() { | |
19019 begin("jtt.micro.ArrayCompare02"); | |
19020 String runString = null; | |
19021 try { | |
19022 // (0) == true | |
19023 runString = "(0)"; | |
19024 if (true != jtt.micro.ArrayCompare02.test(0)) { | |
19025 fail(runString); | |
19026 return; | |
19027 } | |
19028 // (1) == false | |
19029 runString = "(1)"; | |
19030 if (false != jtt.micro.ArrayCompare02.test(1)) { | |
19031 fail(runString); | |
19032 return; | |
19033 } | |
19034 // (2) == true | |
19035 runString = "(2)"; | |
19036 if (true != jtt.micro.ArrayCompare02.test(2)) { | |
19037 fail(runString); | |
19038 return; | |
19039 } | |
19040 // (3) == false | |
19041 runString = "(3)"; | |
19042 if (false != jtt.micro.ArrayCompare02.test(3)) { | |
19043 fail(runString); | |
19044 return; | |
19045 } | |
19046 } catch (Throwable t) { | |
19047 fail(runString, t); | |
19048 return; | |
19049 } | |
19050 pass(); | |
19051 } | |
19052 | |
19053 static void jtt_micro_BC_invokevirtual2() { | |
19054 begin("jtt.micro.BC_invokevirtual2"); | |
19055 String runString = null; | |
19056 try { | |
19057 // (0) == 0 | |
19058 runString = "(0)"; | |
19059 if (0 != jtt.micro.BC_invokevirtual2.test(0)) { | |
19060 fail(runString); | |
19061 return; | |
19062 } | |
19063 // (1) == 1 | |
19064 runString = "(1)"; | |
19065 if (1 != jtt.micro.BC_invokevirtual2.test(1)) { | |
19066 fail(runString); | |
19067 return; | |
19068 } | |
19069 // (2) == 2 | |
19070 runString = "(2)"; | |
19071 if (2 != jtt.micro.BC_invokevirtual2.test(2)) { | |
19072 fail(runString); | |
19073 return; | |
19074 } | |
19075 // (3) == 3 | |
19076 runString = "(3)"; | |
19077 if (3 != jtt.micro.BC_invokevirtual2.test(3)) { | |
19078 fail(runString); | |
19079 return; | |
19080 } | |
19081 // (-4) == -4 | |
19082 runString = "(-4)"; | |
19083 if (-4 != jtt.micro.BC_invokevirtual2.test(-4)) { | |
19084 fail(runString); | |
19085 return; | |
19086 } | |
19087 } catch (Throwable t) { | |
19088 fail(runString, t); | |
19089 return; | |
19090 } | |
19091 pass(); | |
19092 } | |
19093 | |
19094 static void jtt_micro_BigByteParams01() { | |
19095 begin("jtt.micro.BigByteParams01"); | |
19096 String runString = null; | |
19097 try { | |
19098 // (0) == 45 | |
19099 runString = "(0)"; | |
19100 if (45 != jtt.micro.BigByteParams01.test(0)) { | |
19101 fail(runString); | |
19102 return; | |
19103 } | |
19104 // (1) == 45 | |
19105 runString = "(1)"; | |
19106 if (45 != jtt.micro.BigByteParams01.test(1)) { | |
19107 fail(runString); | |
19108 return; | |
19109 } | |
19110 // (2) == 45 | |
19111 runString = "(2)"; | |
19112 if (45 != jtt.micro.BigByteParams01.test(2)) { | |
19113 fail(runString); | |
19114 return; | |
19115 } | |
19116 // (3) == 45 | |
19117 runString = "(3)"; | |
19118 if (45 != jtt.micro.BigByteParams01.test(3)) { | |
19119 fail(runString); | |
19120 return; | |
19121 } | |
19122 // (4) == 0 | |
19123 runString = "(4)"; | |
19124 if (0 != jtt.micro.BigByteParams01.test(4)) { | |
19125 fail(runString); | |
19126 return; | |
19127 } | |
19128 } catch (Throwable t) { | |
19129 fail(runString, t); | |
19130 return; | |
19131 } | |
19132 pass(); | |
19133 } | |
19134 | |
19135 static void jtt_micro_BigDoubleParams02() { | |
19136 begin("jtt.micro.BigDoubleParams02"); | |
19137 String runString = null; | |
19138 try { | |
19139 // (0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 1.0 | |
19140 runString = "(0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19141 if (1.0 != jtt.micro.BigDoubleParams02.test(0, 1.0, 2.0, 3.0, 4.0, | |
19142 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19143 fail(runString); | |
19144 return; | |
19145 } | |
19146 // (1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 2.0 | |
19147 runString = "(1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19148 if (2.0 != jtt.micro.BigDoubleParams02.test(1, 1.0, 2.0, 3.0, 4.0, | |
19149 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19150 fail(runString); | |
19151 return; | |
19152 } | |
19153 // (2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 3.0 | |
19154 runString = "(2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19155 if (3.0 != jtt.micro.BigDoubleParams02.test(2, 1.0, 2.0, 3.0, 4.0, | |
19156 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19157 fail(runString); | |
19158 return; | |
19159 } | |
19160 // (3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 4.0 | |
19161 runString = "(3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19162 if (4.0 != jtt.micro.BigDoubleParams02.test(3, 1.0, 2.0, 3.0, 4.0, | |
19163 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19164 fail(runString); | |
19165 return; | |
19166 } | |
19167 // (4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 5.0 | |
19168 runString = "(4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19169 if (5.0 != jtt.micro.BigDoubleParams02.test(4, 1.0, 2.0, 3.0, 4.0, | |
19170 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19171 fail(runString); | |
19172 return; | |
19173 } | |
19174 // (5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 6.0 | |
19175 runString = "(5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19176 if (6.0 != jtt.micro.BigDoubleParams02.test(5, 1.0, 2.0, 3.0, 4.0, | |
19177 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19178 fail(runString); | |
19179 return; | |
19180 } | |
19181 // (6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 7.0 | |
19182 runString = "(6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19183 if (7.0 != jtt.micro.BigDoubleParams02.test(6, 1.0, 2.0, 3.0, 4.0, | |
19184 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19185 fail(runString); | |
19186 return; | |
19187 } | |
19188 // (7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 8.0 | |
19189 runString = "(7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19190 if (8.0 != jtt.micro.BigDoubleParams02.test(7, 1.0, 2.0, 3.0, 4.0, | |
19191 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19192 fail(runString); | |
19193 return; | |
19194 } | |
19195 // (8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 9.0 | |
19196 runString = "(8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19197 if (9.0 != jtt.micro.BigDoubleParams02.test(8, 1.0, 2.0, 3.0, 4.0, | |
19198 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19199 fail(runString); | |
19200 return; | |
19201 } | |
19202 } catch (Throwable t) { | |
19203 fail(runString, t); | |
19204 return; | |
19205 } | |
19206 pass(); | |
19207 } | |
19208 | |
19209 static void jtt_micro_BigFloatParams01() { | |
19210 begin("jtt.micro.BigFloatParams01"); | |
19211 String runString = null; | |
19212 try { | |
19213 // (0) == 45.0 | |
19214 runString = "(0)"; | |
19215 if (45.0 != jtt.micro.BigFloatParams01.test(0)) { | |
19216 fail(runString); | |
19217 return; | |
19218 } | |
19219 // (1) == 45.0 | |
19220 runString = "(1)"; | |
19221 if (45.0 != jtt.micro.BigFloatParams01.test(1)) { | |
19222 fail(runString); | |
19223 return; | |
19224 } | |
19225 // (2) == 45.0 | |
19226 runString = "(2)"; | |
19227 if (45.0 != jtt.micro.BigFloatParams01.test(2)) { | |
19228 fail(runString); | |
19229 return; | |
19230 } | |
19231 // (3) == 45.0 | |
19232 runString = "(3)"; | |
19233 if (45.0 != jtt.micro.BigFloatParams01.test(3)) { | |
19234 fail(runString); | |
19235 return; | |
19236 } | |
19237 // (4) == 0.0 | |
19238 runString = "(4)"; | |
19239 if (0.0 != jtt.micro.BigFloatParams01.test(4)) { | |
19240 fail(runString); | |
19241 return; | |
19242 } | |
19243 } catch (Throwable t) { | |
19244 fail(runString, t); | |
19245 return; | |
19246 } | |
19247 pass(); | |
19248 } | |
19249 | |
19250 static void jtt_micro_BigFloatParams02() { | |
19251 begin("jtt.micro.BigFloatParams02"); | |
19252 String runString = null; | |
19253 try { | |
19254 // (0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 1.0 | |
19255 runString = "(0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19256 if (1.0f != jtt.micro.BigFloatParams02.test(0, 1.0f, 2.0f, 3.0f, | |
19257 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19258 fail(runString); | |
19259 return; | |
19260 } | |
19261 // (1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 2.0 | |
19262 runString = "(1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19263 if (2.0f != jtt.micro.BigFloatParams02.test(1, 1.0f, 2.0f, 3.0f, | |
19264 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19265 fail(runString); | |
19266 return; | |
19267 } | |
19268 // (2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 3.0 | |
19269 runString = "(2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19270 if (3.0f != jtt.micro.BigFloatParams02.test(2, 1.0f, 2.0f, 3.0f, | |
19271 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19272 fail(runString); | |
19273 return; | |
19274 } | |
19275 // (3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 4.0 | |
19276 runString = "(3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19277 if (4.0f != jtt.micro.BigFloatParams02.test(3, 1.0f, 2.0f, 3.0f, | |
19278 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19279 fail(runString); | |
19280 return; | |
19281 } | |
19282 // (4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 5.0 | |
19283 runString = "(4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19284 if (5.0f != jtt.micro.BigFloatParams02.test(4, 1.0f, 2.0f, 3.0f, | |
19285 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19286 fail(runString); | |
19287 return; | |
19288 } | |
19289 // (5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 6.0 | |
19290 runString = "(5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19291 if (6.0f != jtt.micro.BigFloatParams02.test(5, 1.0f, 2.0f, 3.0f, | |
19292 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19293 fail(runString); | |
19294 return; | |
19295 } | |
19296 // (6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 7.0 | |
19297 runString = "(6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19298 if (7.0f != jtt.micro.BigFloatParams02.test(6, 1.0f, 2.0f, 3.0f, | |
19299 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19300 fail(runString); | |
19301 return; | |
19302 } | |
19303 // (7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 8.0 | |
19304 runString = "(7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19305 if (8.0f != jtt.micro.BigFloatParams02.test(7, 1.0f, 2.0f, 3.0f, | |
19306 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19307 fail(runString); | |
19308 return; | |
19309 } | |
19310 // (8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 9.0 | |
19311 runString = "(8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)"; | |
19312 if (9.0f != jtt.micro.BigFloatParams02.test(8, 1.0f, 2.0f, 3.0f, | |
19313 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) { | |
19314 fail(runString); | |
19315 return; | |
19316 } | |
19317 } catch (Throwable t) { | |
19318 fail(runString, t); | |
19319 return; | |
19320 } | |
19321 pass(); | |
19322 } | |
19323 | |
19324 static void jtt_micro_BigIntParams01() { | |
19325 begin("jtt.micro.BigIntParams01"); | |
19326 String runString = null; | |
19327 try { | |
19328 // (0) == 45 | |
19329 runString = "(0)"; | |
19330 if (45 != jtt.micro.BigIntParams01.test(0)) { | |
19331 fail(runString); | |
19332 return; | |
19333 } | |
19334 // (1) == 45 | |
19335 runString = "(1)"; | |
19336 if (45 != jtt.micro.BigIntParams01.test(1)) { | |
19337 fail(runString); | |
19338 return; | |
19339 } | |
19340 // (2) == 45 | |
19341 runString = "(2)"; | |
19342 if (45 != jtt.micro.BigIntParams01.test(2)) { | |
19343 fail(runString); | |
19344 return; | |
19345 } | |
19346 // (3) == 45 | |
19347 runString = "(3)"; | |
19348 if (45 != jtt.micro.BigIntParams01.test(3)) { | |
19349 fail(runString); | |
19350 return; | |
19351 } | |
19352 // (4) == 0 | |
19353 runString = "(4)"; | |
19354 if (0 != jtt.micro.BigIntParams01.test(4)) { | |
19355 fail(runString); | |
19356 return; | |
19357 } | |
19358 } catch (Throwable t) { | |
19359 fail(runString, t); | |
19360 return; | |
19361 } | |
19362 pass(); | |
19363 } | |
19364 | |
19365 static void jtt_micro_BigIntParams02() { | |
19366 begin("jtt.micro.BigIntParams02"); | |
19367 String runString = null; | |
19368 try { | |
19369 // (0,1,2,3,4,5,6,7,-8,-9) == 1 | |
19370 runString = "(0,1,2,3,4,5,6,7,-8,-9)"; | |
19371 if (1 != jtt.micro.BigIntParams02.test(0, 1, 2, 3, 4, 5, 6, 7, -8, | |
19372 -9)) { | |
19373 fail(runString); | |
19374 return; | |
19375 } | |
19376 // (1,1,2,3,4,5,6,7,-8,-9) == 2 | |
19377 runString = "(1,1,2,3,4,5,6,7,-8,-9)"; | |
19378 if (2 != jtt.micro.BigIntParams02.test(1, 1, 2, 3, 4, 5, 6, 7, -8, | |
19379 -9)) { | |
19380 fail(runString); | |
19381 return; | |
19382 } | |
19383 // (2,1,2,3,4,5,6,7,-8,-9) == 3 | |
19384 runString = "(2,1,2,3,4,5,6,7,-8,-9)"; | |
19385 if (3 != jtt.micro.BigIntParams02.test(2, 1, 2, 3, 4, 5, 6, 7, -8, | |
19386 -9)) { | |
19387 fail(runString); | |
19388 return; | |
19389 } | |
19390 // (3,1,2,3,4,5,6,7,-8,-9) == 4 | |
19391 runString = "(3,1,2,3,4,5,6,7,-8,-9)"; | |
19392 if (4 != jtt.micro.BigIntParams02.test(3, 1, 2, 3, 4, 5, 6, 7, -8, | |
19393 -9)) { | |
19394 fail(runString); | |
19395 return; | |
19396 } | |
19397 // (4,1,2,3,4,5,6,7,-8,-9) == 5 | |
19398 runString = "(4,1,2,3,4,5,6,7,-8,-9)"; | |
19399 if (5 != jtt.micro.BigIntParams02.test(4, 1, 2, 3, 4, 5, 6, 7, -8, | |
19400 -9)) { | |
19401 fail(runString); | |
19402 return; | |
19403 } | |
19404 // (5,1,2,3,4,5,6,7,-8,-9) == 6 | |
19405 runString = "(5,1,2,3,4,5,6,7,-8,-9)"; | |
19406 if (6 != jtt.micro.BigIntParams02.test(5, 1, 2, 3, 4, 5, 6, 7, -8, | |
19407 -9)) { | |
19408 fail(runString); | |
19409 return; | |
19410 } | |
19411 // (6,1,2,3,4,5,6,7,-8,-9) == 7 | |
19412 runString = "(6,1,2,3,4,5,6,7,-8,-9)"; | |
19413 if (7 != jtt.micro.BigIntParams02.test(6, 1, 2, 3, 4, 5, 6, 7, -8, | |
19414 -9)) { | |
19415 fail(runString); | |
19416 return; | |
19417 } | |
19418 // (7,1,2,3,4,5,6,7,-8,-9) == -8 | |
19419 runString = "(7,1,2,3,4,5,6,7,-8,-9)"; | |
19420 if (-8 != jtt.micro.BigIntParams02.test(7, 1, 2, 3, 4, 5, 6, 7, -8, | |
19421 -9)) { | |
19422 fail(runString); | |
19423 return; | |
19424 } | |
19425 // (8,1,2,3,4,5,6,7,-8,-9) == -9 | |
19426 runString = "(8,1,2,3,4,5,6,7,-8,-9)"; | |
19427 if (-9 != jtt.micro.BigIntParams02.test(8, 1, 2, 3, 4, 5, 6, 7, -8, | |
19428 -9)) { | |
19429 fail(runString); | |
19430 return; | |
19431 } | |
19432 } catch (Throwable t) { | |
19433 fail(runString, t); | |
19434 return; | |
19435 } | |
19436 pass(); | |
19437 } | |
19438 | |
19439 static void jtt_micro_BigInterfaceParams01() { | |
19440 begin("jtt.micro.BigInterfaceParams01"); | |
19441 String runString = null; | |
19442 try { | |
19443 // (true,"0","1","2","3","4","5","6","7","8","9") == "A0123456789" | |
19444 runString = "(true,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")"; | |
19445 if (!"A0123456789".equals(jtt.micro.BigInterfaceParams01.test(true, | |
19446 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) { | |
19447 fail(runString); | |
19448 return; | |
19449 } | |
19450 // (false,"0","1","2","3","4","5","6","7","8","9") == "B0123456789" | |
19451 runString = "(false,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")"; | |
19452 if (!"B0123456789".equals(jtt.micro.BigInterfaceParams01.test( | |
19453 false, "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) { | |
19454 fail(runString); | |
19455 return; | |
19456 } | |
19457 } catch (Throwable t) { | |
19458 fail(runString, t); | |
19459 return; | |
19460 } | |
19461 pass(); | |
19462 } | |
19463 | |
19464 static void jtt_micro_BigLongParams02() { | |
19465 begin("jtt.micro.BigLongParams02"); | |
19466 String runString = null; | |
19467 try { | |
19468 // (0,1,2,3,4,5,6,7,-8,-9) == 1 | |
19469 runString = "(0,1,2,3,4,5,6,7,-8,-9)"; | |
19470 if (1L != jtt.micro.BigLongParams02.test(0, 1L, 2L, 3L, 4L, 5L, 6L, | |
19471 7L, -8L, -9L)) { | |
19472 fail(runString); | |
19473 return; | |
19474 } | |
19475 // (1,1,2,3,4,5,6,7,-8,-9) == 2 | |
19476 runString = "(1,1,2,3,4,5,6,7,-8,-9)"; | |
19477 if (2L != jtt.micro.BigLongParams02.test(1, 1L, 2L, 3L, 4L, 5L, 6L, | |
19478 7L, -8L, -9L)) { | |
19479 fail(runString); | |
19480 return; | |
19481 } | |
19482 // (2,1,2,3,4,5,6,7,-8,-9) == 3 | |
19483 runString = "(2,1,2,3,4,5,6,7,-8,-9)"; | |
19484 if (3L != jtt.micro.BigLongParams02.test(2, 1L, 2L, 3L, 4L, 5L, 6L, | |
19485 7L, -8L, -9L)) { | |
19486 fail(runString); | |
19487 return; | |
19488 } | |
19489 // (3,1,2,3,4,5,6,7,-8,-9) == 4 | |
19490 runString = "(3,1,2,3,4,5,6,7,-8,-9)"; | |
19491 if (4L != jtt.micro.BigLongParams02.test(3, 1L, 2L, 3L, 4L, 5L, 6L, | |
19492 7L, -8L, -9L)) { | |
19493 fail(runString); | |
19494 return; | |
19495 } | |
19496 // (4,1,2,3,4,5,6,7,-8,-9) == 5 | |
19497 runString = "(4,1,2,3,4,5,6,7,-8,-9)"; | |
19498 if (5L != jtt.micro.BigLongParams02.test(4, 1L, 2L, 3L, 4L, 5L, 6L, | |
19499 7L, -8L, -9L)) { | |
19500 fail(runString); | |
19501 return; | |
19502 } | |
19503 // (5,1,2,3,4,5,6,7,-8,-9) == 6 | |
19504 runString = "(5,1,2,3,4,5,6,7,-8,-9)"; | |
19505 if (6L != jtt.micro.BigLongParams02.test(5, 1L, 2L, 3L, 4L, 5L, 6L, | |
19506 7L, -8L, -9L)) { | |
19507 fail(runString); | |
19508 return; | |
19509 } | |
19510 // (6,1,2,3,4,5,6,7,-8,-9) == 7 | |
19511 runString = "(6,1,2,3,4,5,6,7,-8,-9)"; | |
19512 if (7L != jtt.micro.BigLongParams02.test(6, 1L, 2L, 3L, 4L, 5L, 6L, | |
19513 7L, -8L, -9L)) { | |
19514 fail(runString); | |
19515 return; | |
19516 } | |
19517 // (7,1,2,3,4,5,6,7,-8,-9) == -8 | |
19518 runString = "(7,1,2,3,4,5,6,7,-8,-9)"; | |
19519 if (-8L != jtt.micro.BigLongParams02.test(7, 1L, 2L, 3L, 4L, 5L, | |
19520 6L, 7L, -8L, -9L)) { | |
19521 fail(runString); | |
19522 return; | |
19523 } | |
19524 // (8,1,2,3,4,5,6,7,-8,-9) == -9 | |
19525 runString = "(8,1,2,3,4,5,6,7,-8,-9)"; | |
19526 if (-9L != jtt.micro.BigLongParams02.test(8, 1L, 2L, 3L, 4L, 5L, | |
19527 6L, 7L, -8L, -9L)) { | |
19528 fail(runString); | |
19529 return; | |
19530 } | |
19531 } catch (Throwable t) { | |
19532 fail(runString, t); | |
19533 return; | |
19534 } | |
19535 pass(); | |
19536 } | |
19537 | |
19538 static void jtt_micro_BigMixedParams01() { | |
19539 begin("jtt.micro.BigMixedParams01"); | |
19540 String runString = null; | |
19541 try { | |
19542 // (0) == 45.0 | |
19543 runString = "(0)"; | |
19544 if (45.0 != jtt.micro.BigMixedParams01.test(0)) { | |
19545 fail(runString); | |
19546 return; | |
19547 } | |
19548 // (1) == 45.0 | |
19549 runString = "(1)"; | |
19550 if (45.0 != jtt.micro.BigMixedParams01.test(1)) { | |
19551 fail(runString); | |
19552 return; | |
19553 } | |
19554 // (2) == 45.0 | |
19555 runString = "(2)"; | |
19556 if (45.0 != jtt.micro.BigMixedParams01.test(2)) { | |
19557 fail(runString); | |
19558 return; | |
19559 } | |
19560 // (3) == 45.0 | |
19561 runString = "(3)"; | |
19562 if (45.0 != jtt.micro.BigMixedParams01.test(3)) { | |
19563 fail(runString); | |
19564 return; | |
19565 } | |
19566 // (4) == 0.0 | |
19567 runString = "(4)"; | |
19568 if (0.0 != jtt.micro.BigMixedParams01.test(4)) { | |
19569 fail(runString); | |
19570 return; | |
19571 } | |
19572 } catch (Throwable t) { | |
19573 fail(runString, t); | |
19574 return; | |
19575 } | |
19576 pass(); | |
19577 } | |
19578 | |
19579 static void jtt_micro_BigMixedParams02() { | |
19580 begin("jtt.micro.BigMixedParams02"); | |
19581 String runString = null; | |
19582 try { | |
19583 // (0,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 1.0 | |
19584 runString = "(0,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19585 if (1.0f != jtt.micro.BigMixedParams02.test(0, -1, -1, -1, -1, | |
19586 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19587 9.0f)) { | |
19588 fail(runString); | |
19589 return; | |
19590 } | |
19591 // (1,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 2.0 | |
19592 runString = "(1,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19593 if (2.0f != jtt.micro.BigMixedParams02.test(1, -1, -1, -1, -1, | |
19594 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19595 9.0f)) { | |
19596 fail(runString); | |
19597 return; | |
19598 } | |
19599 // (2,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 3.0 | |
19600 runString = "(2,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19601 if (3.0f != jtt.micro.BigMixedParams02.test(2, -1, -1, -1, -1, | |
19602 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19603 9.0f)) { | |
19604 fail(runString); | |
19605 return; | |
19606 } | |
19607 // (3,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 4.0 | |
19608 runString = "(3,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19609 if (4.0f != jtt.micro.BigMixedParams02.test(3, -1, -1, -1, -1, | |
19610 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19611 9.0f)) { | |
19612 fail(runString); | |
19613 return; | |
19614 } | |
19615 // (4,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 5.0 | |
19616 runString = "(4,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19617 if (5.0f != jtt.micro.BigMixedParams02.test(4, -1, -1, -1, -1, | |
19618 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19619 9.0f)) { | |
19620 fail(runString); | |
19621 return; | |
19622 } | |
19623 // (5,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 6.0 | |
19624 runString = "(5,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19625 if (6.0f != jtt.micro.BigMixedParams02.test(5, -1, -1, -1, -1, | |
19626 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19627 9.0f)) { | |
19628 fail(runString); | |
19629 return; | |
19630 } | |
19631 // (6,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 7.0 | |
19632 runString = "(6,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19633 if (7.0f != jtt.micro.BigMixedParams02.test(6, -1, -1, -1, -1, | |
19634 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19635 9.0f)) { | |
19636 fail(runString); | |
19637 return; | |
19638 } | |
19639 // (7,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 8.0 | |
19640 runString = "(7,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19641 if (8.0f != jtt.micro.BigMixedParams02.test(7, -1, -1, -1, -1, | |
19642 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19643 9.0f)) { | |
19644 fail(runString); | |
19645 return; | |
19646 } | |
19647 // (8,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 9.0 | |
19648 runString = "(8,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19649 if (9.0f != jtt.micro.BigMixedParams02.test(8, -1, -1, -1, -1, | |
19650 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f, | |
19651 9.0f)) { | |
19652 fail(runString); | |
19653 return; | |
19654 } | |
19655 } catch (Throwable t) { | |
19656 fail(runString, t); | |
19657 return; | |
19658 } | |
19659 pass(); | |
19660 } | |
19661 | |
19662 static void jtt_micro_BigMixedParams03() { | |
19663 begin("jtt.micro.BigMixedParams03"); | |
19664 String runString = null; | |
19665 try { | |
19666 // (0,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 1.0 | |
19667 runString = "(0,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19668 if (1.0 != jtt.micro.BigMixedParams03.test(0, -1, -1, -1, -1, 1.0, | |
19669 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19670 fail(runString); | |
19671 return; | |
19672 } | |
19673 // (1,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 2.0 | |
19674 runString = "(1,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19675 if (2.0 != jtt.micro.BigMixedParams03.test(1, -1, -1, -1, -1, 1.0, | |
19676 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19677 fail(runString); | |
19678 return; | |
19679 } | |
19680 // (2,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 3.0 | |
19681 runString = "(2,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19682 if (3.0 != jtt.micro.BigMixedParams03.test(2, -1, -1, -1, -1, 1.0, | |
19683 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19684 fail(runString); | |
19685 return; | |
19686 } | |
19687 // (3,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 4.0 | |
19688 runString = "(3,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19689 if (4.0 != jtt.micro.BigMixedParams03.test(3, -1, -1, -1, -1, 1.0, | |
19690 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19691 fail(runString); | |
19692 return; | |
19693 } | |
19694 // (4,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 5.0 | |
19695 runString = "(4,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19696 if (5.0 != jtt.micro.BigMixedParams03.test(4, -1, -1, -1, -1, 1.0, | |
19697 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19698 fail(runString); | |
19699 return; | |
19700 } | |
19701 // (5,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 6.0 | |
19702 runString = "(5,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19703 if (6.0 != jtt.micro.BigMixedParams03.test(5, -1, -1, -1, -1, 1.0, | |
19704 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19705 fail(runString); | |
19706 return; | |
19707 } | |
19708 // (6,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 7.0 | |
19709 runString = "(6,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19710 if (7.0 != jtt.micro.BigMixedParams03.test(6, -1, -1, -1, -1, 1.0, | |
19711 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19712 fail(runString); | |
19713 return; | |
19714 } | |
19715 // (7,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 8.0 | |
19716 runString = "(7,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19717 if (8.0 != jtt.micro.BigMixedParams03.test(7, -1, -1, -1, -1, 1.0, | |
19718 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19719 fail(runString); | |
19720 return; | |
19721 } | |
19722 // (8,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0) == 9.0 | |
19723 runString = "(8,-1,-1,-1,-1,1.0,2.0,3.0,4.0,-1,-1,5.0,6.0,7.0,8.0,9.0)"; | |
19724 if (9.0 != jtt.micro.BigMixedParams03.test(8, -1, -1, -1, -1, 1.0, | |
19725 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) { | |
19726 fail(runString); | |
19727 return; | |
19728 } | |
19729 } catch (Throwable t) { | |
19730 fail(runString, t); | |
19731 return; | |
19732 } | |
19733 pass(); | |
19734 } | |
19735 | |
19736 static void jtt_micro_BigObjectParams01() { | |
19737 begin("jtt.micro.BigObjectParams01"); | |
19738 String runString = null; | |
19739 try { | |
19740 // ("0","1","2","3","4","5","6","7","8","9") == "0" | |
19741 runString = "(\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")"; | |
19742 if (!"0".equals(jtt.micro.BigObjectParams01.test("0", "1", "2", | |
19743 "3", "4", "5", "6", "7", "8", "9"))) { | |
19744 fail(runString); | |
19745 return; | |
19746 } | |
19747 // ("a",null,null,null,null,null,null,null,null,null) == "a" | |
19748 runString = "(\"a\",null,null,null,null,null,null,null,null,null)"; | |
19749 if (!"a".equals(jtt.micro.BigObjectParams01.test("a", null, null, | |
19750 null, null, null, null, null, null, null))) { | |
19751 fail(runString); | |
19752 return; | |
19753 } | |
19754 } catch (Throwable t) { | |
19755 fail(runString, t); | |
19756 return; | |
19757 } | |
19758 pass(); | |
19759 } | |
19760 | |
19761 static void jtt_micro_BigObjectParams02() { | |
19762 begin("jtt.micro.BigObjectParams02"); | |
19763 String runString = null; | |
19764 try { | |
19765 // ("0","1","2","3","4","5","6","7","8","9") == "0123456789" | |
19766 runString = "(\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")"; | |
19767 if (!"0123456789".equals(jtt.micro.BigObjectParams02.test("0", "1", | |
19768 "2", "3", "4", "5", "6", "7", "8", "9"))) { | |
19769 fail(runString); | |
19770 return; | |
19771 } | |
19772 } catch (Throwable t) { | |
19773 fail(runString, t); | |
19774 return; | |
19775 } | |
19776 pass(); | |
19777 } | |
19778 | |
19779 static void jtt_micro_BigParamsAlignment() { | |
19780 begin("jtt.micro.BigParamsAlignment"); | |
19781 String runString = null; | |
19782 try { | |
19783 // (0) == 45 | |
19784 runString = "(0)"; | |
19785 if (45 != jtt.micro.BigParamsAlignment.test(0)) { | |
19786 fail(runString); | |
19787 return; | |
19788 } | |
19789 // (1) == 55 | |
19790 runString = "(1)"; | |
19791 if (55 != jtt.micro.BigParamsAlignment.test(1)) { | |
19792 fail(runString); | |
19793 return; | |
19794 } | |
19795 // (2) == 45 | |
19796 runString = "(2)"; | |
19797 if (45 != jtt.micro.BigParamsAlignment.test(2)) { | |
19798 fail(runString); | |
19799 return; | |
19800 } | |
19801 // (3) == 55 | |
19802 runString = "(3)"; | |
19803 if (55 != jtt.micro.BigParamsAlignment.test(3)) { | |
19804 fail(runString); | |
19805 return; | |
19806 } | |
19807 // (4) == 66 | |
19808 runString = "(4)"; | |
19809 if (66 != jtt.micro.BigParamsAlignment.test(4)) { | |
19810 fail(runString); | |
19811 return; | |
19812 } | |
19813 // (5) == 78 | |
19814 runString = "(5)"; | |
19815 if (78 != jtt.micro.BigParamsAlignment.test(5)) { | |
19816 fail(runString); | |
19817 return; | |
19818 } | |
19819 // (6) == 0 | |
19820 runString = "(6)"; | |
19821 if (0 != jtt.micro.BigParamsAlignment.test(6)) { | |
19822 fail(runString); | |
19823 return; | |
19824 } | |
19825 } catch (Throwable t) { | |
19826 fail(runString, t); | |
19827 return; | |
19828 } | |
19829 pass(); | |
19830 } | |
19831 | |
19832 static void jtt_micro_BigShortParams01() { | |
19833 begin("jtt.micro.BigShortParams01"); | |
19834 String runString = null; | |
19835 try { | |
19836 // (0) == 45 | |
19837 runString = "(0)"; | |
19838 if (45 != jtt.micro.BigShortParams01.test(0)) { | |
19839 fail(runString); | |
19840 return; | |
19841 } | |
19842 // (1) == 45 | |
19843 runString = "(1)"; | |
19844 if (45 != jtt.micro.BigShortParams01.test(1)) { | |
19845 fail(runString); | |
19846 return; | |
19847 } | |
19848 // (2) == 45 | |
19849 runString = "(2)"; | |
19850 if (45 != jtt.micro.BigShortParams01.test(2)) { | |
19851 fail(runString); | |
19852 return; | |
19853 } | |
19854 // (3) == 45 | |
19855 runString = "(3)"; | |
19856 if (45 != jtt.micro.BigShortParams01.test(3)) { | |
19857 fail(runString); | |
19858 return; | |
19859 } | |
19860 // (4) == 0 | |
19861 runString = "(4)"; | |
19862 if (0 != jtt.micro.BigShortParams01.test(4)) { | |
19863 fail(runString); | |
19864 return; | |
19865 } | |
19866 } catch (Throwable t) { | |
19867 fail(runString, t); | |
19868 return; | |
19869 } | |
19870 pass(); | |
19871 } | |
19872 | |
19873 static void jtt_micro_BigVirtualParams01() { | |
19874 begin("jtt.micro.BigVirtualParams01"); | |
19875 String runString = null; | |
19876 try { | |
19877 // (true,"0","1","2","3","4","5","6","7","8","9") == "A0123456789" | |
19878 runString = "(true,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")"; | |
19879 if (!"A0123456789".equals(jtt.micro.BigVirtualParams01.test(true, | |
19880 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) { | |
19881 fail(runString); | |
19882 return; | |
19883 } | |
19884 // (false,"0","1","2","3","4","5","6","7","8","9") == "B0123456789" | |
19885 runString = "(false,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")"; | |
19886 if (!"B0123456789".equals(jtt.micro.BigVirtualParams01.test(false, | |
19887 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) { | |
19888 fail(runString); | |
19889 return; | |
19890 } | |
19891 } catch (Throwable t) { | |
19892 fail(runString, t); | |
19893 return; | |
19894 } | |
19895 pass(); | |
19896 } | |
19897 | |
19898 static void jtt_micro_Bubblesort() { | |
19899 begin("jtt.micro.Bubblesort"); | |
19900 String runString = null; | |
19901 try { | |
19902 // (0) == -9 | |
19903 runString = "(0)"; | |
19904 if (-9 != jtt.micro.Bubblesort.test(0)) { | |
19905 fail(runString); | |
19906 return; | |
19907 } | |
19908 // (1) == 0 | |
19909 runString = "(1)"; | |
19910 if (0 != jtt.micro.Bubblesort.test(1)) { | |
19911 fail(runString); | |
19912 return; | |
19913 } | |
19914 // (2) == 0 | |
19915 runString = "(2)"; | |
19916 if (0 != jtt.micro.Bubblesort.test(2)) { | |
19917 fail(runString); | |
19918 return; | |
19919 } | |
19920 // (3) == 1 | |
19921 runString = "(3)"; | |
19922 if (1 != jtt.micro.Bubblesort.test(3)) { | |
19923 fail(runString); | |
19924 return; | |
19925 } | |
19926 // (4) == 5 | |
19927 runString = "(4)"; | |
19928 if (5 != jtt.micro.Bubblesort.test(4)) { | |
19929 fail(runString); | |
19930 return; | |
19931 } | |
19932 // (5) == 8 | |
19933 runString = "(5)"; | |
19934 if (8 != jtt.micro.Bubblesort.test(5)) { | |
19935 fail(runString); | |
19936 return; | |
19937 } | |
19938 // (6) == 23 | |
19939 runString = "(6)"; | |
19940 if (23 != jtt.micro.Bubblesort.test(6)) { | |
19941 fail(runString); | |
19942 return; | |
19943 } | |
19944 // (7) == 882 | |
19945 runString = "(7)"; | |
19946 if (882 != jtt.micro.Bubblesort.test(7)) { | |
19947 fail(runString); | |
19948 return; | |
19949 } | |
19950 } catch (Throwable t) { | |
19951 fail(runString, t); | |
19952 return; | |
19953 } | |
19954 pass(); | |
19955 } | |
19956 | |
19957 static void jtt_micro_Fibonacci() { | |
19958 begin("jtt.micro.Fibonacci"); | |
19959 String runString = null; | |
19960 try { | |
19961 // (0) == 0 | |
19962 runString = "(0)"; | |
19963 if (0 != jtt.micro.Fibonacci.test(0)) { | |
19964 fail(runString); | |
19965 return; | |
19966 } | |
19967 // (1) == 1 | |
19968 runString = "(1)"; | |
19969 if (1 != jtt.micro.Fibonacci.test(1)) { | |
19970 fail(runString); | |
19971 return; | |
19972 } | |
19973 // (2) == 1 | |
19974 runString = "(2)"; | |
19975 if (1 != jtt.micro.Fibonacci.test(2)) { | |
19976 fail(runString); | |
19977 return; | |
19978 } | |
19979 // (3) == 2 | |
19980 runString = "(3)"; | |
19981 if (2 != jtt.micro.Fibonacci.test(3)) { | |
19982 fail(runString); | |
19983 return; | |
19984 } | |
19985 // (4) == 3 | |
19986 runString = "(4)"; | |
19987 if (3 != jtt.micro.Fibonacci.test(4)) { | |
19988 fail(runString); | |
19989 return; | |
19990 } | |
19991 // (5) == 5 | |
19992 runString = "(5)"; | |
19993 if (5 != jtt.micro.Fibonacci.test(5)) { | |
19994 fail(runString); | |
19995 return; | |
19996 } | |
19997 // (6) == 8 | |
19998 runString = "(6)"; | |
19999 if (8 != jtt.micro.Fibonacci.test(6)) { | |
20000 fail(runString); | |
20001 return; | |
20002 } | |
20003 // (7) == 13 | |
20004 runString = "(7)"; | |
20005 if (13 != jtt.micro.Fibonacci.test(7)) { | |
20006 fail(runString); | |
20007 return; | |
20008 } | |
20009 } catch (Throwable t) { | |
20010 fail(runString, t); | |
20011 return; | |
20012 } | |
20013 pass(); | |
20014 } | |
20015 | |
20016 static void jtt_micro_InvokeVirtual_01() { | |
20017 begin("jtt.micro.InvokeVirtual_01"); | |
20018 String runString = null; | |
20019 try { | |
20020 // (0) == 0 | |
20021 runString = "(0)"; | |
20022 if (0 != jtt.micro.InvokeVirtual_01.test(0)) { | |
20023 fail(runString); | |
20024 return; | |
20025 } | |
20026 // (1) == 11 | |
20027 runString = "(1)"; | |
20028 if (11 != jtt.micro.InvokeVirtual_01.test(1)) { | |
20029 fail(runString); | |
20030 return; | |
20031 } | |
20032 // (2) == 22 | |
20033 runString = "(2)"; | |
20034 if (22 != jtt.micro.InvokeVirtual_01.test(2)) { | |
20035 fail(runString); | |
20036 return; | |
20037 } | |
20038 // (3) == 42 | |
20039 runString = "(3)"; | |
20040 if (42 != jtt.micro.InvokeVirtual_01.test(3)) { | |
20041 fail(runString); | |
20042 return; | |
20043 } | |
20044 } catch (Throwable t) { | |
20045 fail(runString, t); | |
20046 return; | |
20047 } | |
20048 pass(); | |
20049 } | |
20050 | |
20051 static void jtt_micro_InvokeVirtual_02() { | |
20052 begin("jtt.micro.InvokeVirtual_02"); | |
20053 String runString = null; | |
20054 try { | |
20055 // (0) == 0 | |
20056 runString = "(0)"; | |
20057 if (0L != jtt.micro.InvokeVirtual_02.test(0L)) { | |
20058 fail(runString); | |
20059 return; | |
20060 } | |
20061 // (1) == 11 | |
20062 runString = "(1)"; | |
20063 if (11L != jtt.micro.InvokeVirtual_02.test(1L)) { | |
20064 fail(runString); | |
20065 return; | |
20066 } | |
20067 // (2) == 22 | |
20068 runString = "(2)"; | |
20069 if (22L != jtt.micro.InvokeVirtual_02.test(2L)) { | |
20070 fail(runString); | |
20071 return; | |
20072 } | |
20073 // (3) == 42 | |
20074 runString = "(3)"; | |
20075 if (42L != jtt.micro.InvokeVirtual_02.test(3L)) { | |
20076 fail(runString); | |
20077 return; | |
20078 } | |
20079 } catch (Throwable t) { | |
20080 fail(runString, t); | |
20081 return; | |
20082 } | |
20083 pass(); | |
20084 } | |
20085 | |
20086 static void jtt_micro_Matrix01() { | |
20087 begin("jtt.micro.Matrix01"); | |
20088 String runString = null; | |
20089 try { | |
20090 // (0) == 8 | |
20091 runString = "(0)"; | |
20092 if (8 != jtt.micro.Matrix01.test(0)) { | |
20093 fail(runString); | |
20094 return; | |
20095 } | |
20096 // (1) == 34 | |
20097 runString = "(1)"; | |
20098 if (34 != jtt.micro.Matrix01.test(1)) { | |
20099 fail(runString); | |
20100 return; | |
20101 } | |
20102 // (2) == 152 | |
20103 runString = "(2)"; | |
20104 if (152 != jtt.micro.Matrix01.test(2)) { | |
20105 fail(runString); | |
20106 return; | |
20107 } | |
20108 // (3) == 204 | |
20109 runString = "(3)"; | |
20110 if (204 != jtt.micro.Matrix01.test(3)) { | |
20111 fail(runString); | |
20112 return; | |
20113 } | |
20114 // (4) == 1547 | |
20115 runString = "(4)"; | |
20116 if (1547 != jtt.micro.Matrix01.test(4)) { | |
20117 fail(runString); | |
20118 return; | |
20119 } | |
20120 // (5) == 42 | |
20121 runString = "(5)"; | |
20122 if (42 != jtt.micro.Matrix01.test(5)) { | |
20123 fail(runString); | |
20124 return; | |
20125 } | |
20126 } catch (Throwable t) { | |
20127 fail(runString, t); | |
20128 return; | |
20129 } | |
20130 pass(); | |
20131 } | |
20132 | |
20133 static void jtt_micro_StrangeFrames() { | |
20134 begin("jtt.micro.StrangeFrames"); | |
20135 String runString = null; | |
20136 try { | |
20137 // (0) == true | |
20138 runString = "(0)"; | |
20139 if (true != jtt.micro.StrangeFrames.test(0)) { | |
20140 fail(runString); | |
20141 return; | |
20142 } | |
20143 } catch (Throwable t) { | |
20144 fail(runString, t); | |
20145 return; | |
20146 } | |
20147 pass(); | |
20148 } | |
20149 | |
20150 static void jtt_micro_String_format01() { | |
20151 begin("jtt.micro.String_format01"); | |
20152 String runString = null; | |
20153 try { | |
20154 // ("World") == "Hello World" | |
20155 runString = "(\"World\")"; | |
20156 if (!"Hello World".equals(jtt.micro.String_format01.test("World"))) { | |
20157 fail(runString); | |
20158 return; | |
20159 } | |
20160 // ("New World Order") == "Hello New World Order" | |
20161 runString = "(\"New World Order\")"; | |
20162 if (!"Hello New World Order".equals(jtt.micro.String_format01 | |
20163 .test("New World Order"))) { | |
20164 fail(runString); | |
20165 return; | |
20166 } | |
20167 } catch (Throwable t) { | |
20168 fail(runString, t); | |
20169 return; | |
20170 } | |
20171 pass(); | |
20172 } | |
20173 | |
20174 static void jtt_micro_String_format02() { | |
20175 begin("jtt.micro.String_format02"); | |
20176 String runString = null; | |
20177 try { | |
20178 // (0) == "Hello 0" | |
20179 runString = "(0)"; | |
20180 if (!"Hello 0".equals(jtt.micro.String_format02.test(0))) { | |
20181 fail(runString); | |
20182 return; | |
20183 } | |
20184 // (-11) == "Hello -11" | |
20185 runString = "(-11)"; | |
20186 if (!"Hello -11".equals(jtt.micro.String_format02.test(-11))) { | |
20187 fail(runString); | |
20188 return; | |
20189 } | |
20190 // (-2147483648) == "Hello -2147483648" | |
20191 runString = "(-2147483648)"; | |
20192 if (!"Hello -2147483648".equals(jtt.micro.String_format02 | |
20193 .test(-2147483648))) { | |
20194 fail(runString); | |
20195 return; | |
20196 } | |
20197 // (2147483647) == "Hello 2147483647" | |
20198 runString = "(2147483647)"; | |
20199 if (!"Hello 2147483647".equals(jtt.micro.String_format02 | |
20200 .test(2147483647))) { | |
20201 fail(runString); | |
20202 return; | |
20203 } | |
20204 } catch (Throwable t) { | |
20205 fail(runString, t); | |
20206 return; | |
20207 } | |
20208 pass(); | |
20209 } | |
20210 | |
20211 static void jtt_micro_VarArgs_String01() { | |
20212 begin("jtt.micro.VarArgs_String01"); | |
20213 String runString = null; | |
20214 try { | |
20215 // (0) == "a" | |
20216 runString = "(0)"; | |
20217 if (!"a".equals(jtt.micro.VarArgs_String01.test(0))) { | |
20218 fail(runString); | |
20219 return; | |
20220 } | |
20221 // (1) == null | |
20222 runString = "(1)"; | |
20223 if (null != jtt.micro.VarArgs_String01.test(1)) { | |
20224 fail(runString); | |
20225 return; | |
20226 } | |
20227 // (2) == "test" | |
20228 runString = "(2)"; | |
20229 if (!"test".equals(jtt.micro.VarArgs_String01.test(2))) { | |
20230 fail(runString); | |
20231 return; | |
20232 } | |
20233 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20234 try { | |
20235 runString = "(3)"; | |
20236 jtt.micro.VarArgs_String01.test(3); | |
20237 fail(runString); | |
20238 return; | |
20239 } catch (Throwable e) { | |
20240 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20241 fail(runString, e); | |
20242 return; | |
20243 } | |
20244 } | |
20245 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20246 try { | |
20247 runString = "(4)"; | |
20248 jtt.micro.VarArgs_String01.test(4); | |
20249 fail(runString); | |
20250 return; | |
20251 } catch (Throwable e) { | |
20252 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20253 fail(runString, e); | |
20254 return; | |
20255 } | |
20256 } | |
20257 } catch (Throwable t) { | |
20258 fail(runString, t); | |
20259 return; | |
20260 } | |
20261 pass(); | |
20262 } | |
20263 | |
20264 static void jtt_micro_VarArgs_boolean01() { | |
20265 begin("jtt.micro.VarArgs_boolean01"); | |
20266 String runString = null; | |
20267 try { | |
20268 // (0) == true | |
20269 runString = "(0)"; | |
20270 if (true != jtt.micro.VarArgs_boolean01.test(0)) { | |
20271 fail(runString); | |
20272 return; | |
20273 } | |
20274 // (1) == false | |
20275 runString = "(1)"; | |
20276 if (false != jtt.micro.VarArgs_boolean01.test(1)) { | |
20277 fail(runString); | |
20278 return; | |
20279 } | |
20280 // (2) == true | |
20281 runString = "(2)"; | |
20282 if (true != jtt.micro.VarArgs_boolean01.test(2)) { | |
20283 fail(runString); | |
20284 return; | |
20285 } | |
20286 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20287 try { | |
20288 runString = "(3)"; | |
20289 jtt.micro.VarArgs_boolean01.test(3); | |
20290 fail(runString); | |
20291 return; | |
20292 } catch (Throwable e) { | |
20293 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20294 fail(runString, e); | |
20295 return; | |
20296 } | |
20297 } | |
20298 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20299 try { | |
20300 runString = "(4)"; | |
20301 jtt.micro.VarArgs_boolean01.test(4); | |
20302 fail(runString); | |
20303 return; | |
20304 } catch (Throwable e) { | |
20305 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20306 fail(runString, e); | |
20307 return; | |
20308 } | |
20309 } | |
20310 } catch (Throwable t) { | |
20311 fail(runString, t); | |
20312 return; | |
20313 } | |
20314 pass(); | |
20315 } | |
20316 | |
20317 static void jtt_micro_VarArgs_byte01() { | |
20318 begin("jtt.micro.VarArgs_byte01"); | |
20319 String runString = null; | |
20320 try { | |
20321 // (0) == 1 | |
20322 runString = "(0)"; | |
20323 if ((byte) 1 != jtt.micro.VarArgs_byte01.test(0)) { | |
20324 fail(runString); | |
20325 return; | |
20326 } | |
20327 // (1) == 2 | |
20328 runString = "(1)"; | |
20329 if ((byte) 2 != jtt.micro.VarArgs_byte01.test(1)) { | |
20330 fail(runString); | |
20331 return; | |
20332 } | |
20333 // (2) == 3 | |
20334 runString = "(2)"; | |
20335 if ((byte) 3 != jtt.micro.VarArgs_byte01.test(2)) { | |
20336 fail(runString); | |
20337 return; | |
20338 } | |
20339 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20340 try { | |
20341 runString = "(3)"; | |
20342 jtt.micro.VarArgs_byte01.test(3); | |
20343 fail(runString); | |
20344 return; | |
20345 } catch (Throwable e) { | |
20346 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20347 fail(runString, e); | |
20348 return; | |
20349 } | |
20350 } | |
20351 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20352 try { | |
20353 runString = "(4)"; | |
20354 jtt.micro.VarArgs_byte01.test(4); | |
20355 fail(runString); | |
20356 return; | |
20357 } catch (Throwable e) { | |
20358 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20359 fail(runString, e); | |
20360 return; | |
20361 } | |
20362 } | |
20363 } catch (Throwable t) { | |
20364 fail(runString, t); | |
20365 return; | |
20366 } | |
20367 pass(); | |
20368 } | |
20369 | |
20370 static void jtt_micro_VarArgs_char01() { | |
20371 begin("jtt.micro.VarArgs_char01"); | |
20372 String runString = null; | |
20373 try { | |
20374 // (0) == 'a' | |
20375 runString = "(0)"; | |
20376 if ((char) 97 != jtt.micro.VarArgs_char01.test(0)) { | |
20377 fail(runString); | |
20378 return; | |
20379 } | |
20380 // (1) == 'b' | |
20381 runString = "(1)"; | |
20382 if ((char) 98 != jtt.micro.VarArgs_char01.test(1)) { | |
20383 fail(runString); | |
20384 return; | |
20385 } | |
20386 // (2) == 'c' | |
20387 runString = "(2)"; | |
20388 if ((char) 99 != jtt.micro.VarArgs_char01.test(2)) { | |
20389 fail(runString); | |
20390 return; | |
20391 } | |
20392 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20393 try { | |
20394 runString = "(3)"; | |
20395 jtt.micro.VarArgs_char01.test(3); | |
20396 fail(runString); | |
20397 return; | |
20398 } catch (Throwable e) { | |
20399 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20400 fail(runString, e); | |
20401 return; | |
20402 } | |
20403 } | |
20404 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20405 try { | |
20406 runString = "(4)"; | |
20407 jtt.micro.VarArgs_char01.test(4); | |
20408 fail(runString); | |
20409 return; | |
20410 } catch (Throwable e) { | |
20411 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20412 fail(runString, e); | |
20413 return; | |
20414 } | |
20415 } | |
20416 } catch (Throwable t) { | |
20417 fail(runString, t); | |
20418 return; | |
20419 } | |
20420 pass(); | |
20421 } | |
20422 | |
20423 static void jtt_micro_VarArgs_double01() { | |
20424 begin("jtt.micro.VarArgs_double01"); | |
20425 String runString = null; | |
20426 try { | |
20427 // (0) == 0.0 | |
20428 runString = "(0)"; | |
20429 if (0.0 != jtt.micro.VarArgs_double01.test(0)) { | |
20430 fail(runString); | |
20431 return; | |
20432 } | |
20433 // (1) == 1.0 | |
20434 runString = "(1)"; | |
20435 if (1.0 != jtt.micro.VarArgs_double01.test(1)) { | |
20436 fail(runString); | |
20437 return; | |
20438 } | |
20439 // (2) == 2.0 | |
20440 runString = "(2)"; | |
20441 if (2.0 != jtt.micro.VarArgs_double01.test(2)) { | |
20442 fail(runString); | |
20443 return; | |
20444 } | |
20445 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20446 try { | |
20447 runString = "(3)"; | |
20448 jtt.micro.VarArgs_double01.test(3); | |
20449 fail(runString); | |
20450 return; | |
20451 } catch (Throwable e) { | |
20452 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20453 fail(runString, e); | |
20454 return; | |
20455 } | |
20456 } | |
20457 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20458 try { | |
20459 runString = "(4)"; | |
20460 jtt.micro.VarArgs_double01.test(4); | |
20461 fail(runString); | |
20462 return; | |
20463 } catch (Throwable e) { | |
20464 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20465 fail(runString, e); | |
20466 return; | |
20467 } | |
20468 } | |
20469 } catch (Throwable t) { | |
20470 fail(runString, t); | |
20471 return; | |
20472 } | |
20473 pass(); | |
20474 } | |
20475 | |
20476 static void jtt_micro_VarArgs_float01() { | |
20477 begin("jtt.micro.VarArgs_float01"); | |
20478 String runString = null; | |
20479 try { | |
20480 // (0) == 0.0 | |
20481 runString = "(0)"; | |
20482 if (0.0f != jtt.micro.VarArgs_float01.test(0)) { | |
20483 fail(runString); | |
20484 return; | |
20485 } | |
20486 // (1) == 1.0 | |
20487 runString = "(1)"; | |
20488 if (1.0f != jtt.micro.VarArgs_float01.test(1)) { | |
20489 fail(runString); | |
20490 return; | |
20491 } | |
20492 // (2) == 2.0 | |
20493 runString = "(2)"; | |
20494 if (2.0f != jtt.micro.VarArgs_float01.test(2)) { | |
20495 fail(runString); | |
20496 return; | |
20497 } | |
20498 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20499 try { | |
20500 runString = "(3)"; | |
20501 jtt.micro.VarArgs_float01.test(3); | |
20502 fail(runString); | |
20503 return; | |
20504 } catch (Throwable e) { | |
20505 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20506 fail(runString, e); | |
20507 return; | |
20508 } | |
20509 } | |
20510 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20511 try { | |
20512 runString = "(4)"; | |
20513 jtt.micro.VarArgs_float01.test(4); | |
20514 fail(runString); | |
20515 return; | |
20516 } catch (Throwable e) { | |
20517 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20518 fail(runString, e); | |
20519 return; | |
20520 } | |
20521 } | |
20522 } catch (Throwable t) { | |
20523 fail(runString, t); | |
20524 return; | |
20525 } | |
20526 pass(); | |
20527 } | |
20528 | |
20529 static void jtt_micro_VarArgs_int01() { | |
20530 begin("jtt.micro.VarArgs_int01"); | |
20531 String runString = null; | |
20532 try { | |
20533 // (0) == 0 | |
20534 runString = "(0)"; | |
20535 if (0 != jtt.micro.VarArgs_int01.test(0)) { | |
20536 fail(runString); | |
20537 return; | |
20538 } | |
20539 // (1) == 1 | |
20540 runString = "(1)"; | |
20541 if (1 != jtt.micro.VarArgs_int01.test(1)) { | |
20542 fail(runString); | |
20543 return; | |
20544 } | |
20545 // (2) == 2 | |
20546 runString = "(2)"; | |
20547 if (2 != jtt.micro.VarArgs_int01.test(2)) { | |
20548 fail(runString); | |
20549 return; | |
20550 } | |
20551 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20552 try { | |
20553 runString = "(3)"; | |
20554 jtt.micro.VarArgs_int01.test(3); | |
20555 fail(runString); | |
20556 return; | |
20557 } catch (Throwable e) { | |
20558 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20559 fail(runString, e); | |
20560 return; | |
20561 } | |
20562 } | |
20563 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20564 try { | |
20565 runString = "(4)"; | |
20566 jtt.micro.VarArgs_int01.test(4); | |
20567 fail(runString); | |
20568 return; | |
20569 } catch (Throwable e) { | |
20570 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20571 fail(runString, e); | |
20572 return; | |
20573 } | |
20574 } | |
20575 } catch (Throwable t) { | |
20576 fail(runString, t); | |
20577 return; | |
20578 } | |
20579 pass(); | |
20580 } | |
20581 | |
20582 static void jtt_micro_VarArgs_long01() { | |
20583 begin("jtt.micro.VarArgs_long01"); | |
20584 String runString = null; | |
20585 try { | |
20586 // (0) == 0 | |
20587 runString = "(0)"; | |
20588 if (0L != jtt.micro.VarArgs_long01.test(0)) { | |
20589 fail(runString); | |
20590 return; | |
20591 } | |
20592 // (1) == 1 | |
20593 runString = "(1)"; | |
20594 if (1L != jtt.micro.VarArgs_long01.test(1)) { | |
20595 fail(runString); | |
20596 return; | |
20597 } | |
20598 // (2) == 2 | |
20599 runString = "(2)"; | |
20600 if (2L != jtt.micro.VarArgs_long01.test(2)) { | |
20601 fail(runString); | |
20602 return; | |
20603 } | |
20604 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20605 try { | |
20606 runString = "(3)"; | |
20607 jtt.micro.VarArgs_long01.test(3); | |
20608 fail(runString); | |
20609 return; | |
20610 } catch (Throwable e) { | |
20611 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20612 fail(runString, e); | |
20613 return; | |
20614 } | |
20615 } | |
20616 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20617 try { | |
20618 runString = "(4)"; | |
20619 jtt.micro.VarArgs_long01.test(4); | |
20620 fail(runString); | |
20621 return; | |
20622 } catch (Throwable e) { | |
20623 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20624 fail(runString, e); | |
20625 return; | |
20626 } | |
20627 } | |
20628 } catch (Throwable t) { | |
20629 fail(runString, t); | |
20630 return; | |
20631 } | |
20632 pass(); | |
20633 } | |
20634 | |
20635 static void jtt_micro_VarArgs_short01() { | |
20636 begin("jtt.micro.VarArgs_short01"); | |
20637 String runString = null; | |
20638 try { | |
20639 // (0) == 0 | |
20640 runString = "(0)"; | |
20641 if ((short) 0 != jtt.micro.VarArgs_short01.test(0)) { | |
20642 fail(runString); | |
20643 return; | |
20644 } | |
20645 // (1) == 1 | |
20646 runString = "(1)"; | |
20647 if ((short) 1 != jtt.micro.VarArgs_short01.test(1)) { | |
20648 fail(runString); | |
20649 return; | |
20650 } | |
20651 // (2) == 2 | |
20652 runString = "(2)"; | |
20653 if ((short) 2 != jtt.micro.VarArgs_short01.test(2)) { | |
20654 fail(runString); | |
20655 return; | |
20656 } | |
20657 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20658 try { | |
20659 runString = "(3)"; | |
20660 jtt.micro.VarArgs_short01.test(3); | |
20661 fail(runString); | |
20662 return; | |
20663 } catch (Throwable e) { | |
20664 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20665 fail(runString, e); | |
20666 return; | |
20667 } | |
20668 } | |
20669 // (4) == !java.lang.ArrayIndexOutOfBoundsException | |
20670 try { | |
20671 runString = "(4)"; | |
20672 jtt.micro.VarArgs_short01.test(4); | |
20673 fail(runString); | |
20674 return; | |
20675 } catch (Throwable e) { | |
20676 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20677 fail(runString, e); | |
20678 return; | |
20679 } | |
20680 } | |
20681 } catch (Throwable t) { | |
20682 fail(runString, t); | |
20683 return; | |
20684 } | |
20685 pass(); | |
20686 } | |
20687 | |
20688 static void jtt_reflect_Array_get01() { | |
20689 begin("jtt.reflect.Array_get01"); | |
20690 String runString = null; | |
20691 try { | |
20692 // (0) == "0" | |
20693 runString = "(0)"; | |
20694 if (!"0".equals(jtt.reflect.Array_get01.test(0))) { | |
20695 fail(runString); | |
20696 return; | |
20697 } | |
20698 // (1) == "1" | |
20699 runString = "(1)"; | |
20700 if (!"1".equals(jtt.reflect.Array_get01.test(1))) { | |
20701 fail(runString); | |
20702 return; | |
20703 } | |
20704 // (2) == "2" | |
20705 runString = "(2)"; | |
20706 if (!"2".equals(jtt.reflect.Array_get01.test(2))) { | |
20707 fail(runString); | |
20708 return; | |
20709 } | |
20710 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20711 try { | |
20712 runString = "(3)"; | |
20713 jtt.reflect.Array_get01.test(3); | |
20714 fail(runString); | |
20715 return; | |
20716 } catch (Throwable e) { | |
20717 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20718 fail(runString, e); | |
20719 return; | |
20720 } | |
20721 } | |
20722 } catch (Throwable t) { | |
20723 fail(runString, t); | |
20724 return; | |
20725 } | |
20726 pass(); | |
20727 } | |
20728 | |
20729 static void jtt_reflect_Array_get02() { | |
20730 begin("jtt.reflect.Array_get02"); | |
20731 String runString = null; | |
20732 try { | |
20733 // (0) == 11 | |
20734 runString = "(0)"; | |
20735 if (11 != jtt.reflect.Array_get02.test(0)) { | |
20736 fail(runString); | |
20737 return; | |
20738 } | |
20739 // (1) == 21 | |
20740 runString = "(1)"; | |
20741 if (21 != jtt.reflect.Array_get02.test(1)) { | |
20742 fail(runString); | |
20743 return; | |
20744 } | |
20745 // (2) == 42 | |
20746 runString = "(2)"; | |
20747 if (42 != jtt.reflect.Array_get02.test(2)) { | |
20748 fail(runString); | |
20749 return; | |
20750 } | |
20751 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20752 try { | |
20753 runString = "(3)"; | |
20754 jtt.reflect.Array_get02.test(3); | |
20755 fail(runString); | |
20756 return; | |
20757 } catch (Throwable e) { | |
20758 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20759 fail(runString, e); | |
20760 return; | |
20761 } | |
20762 } | |
20763 } catch (Throwable t) { | |
20764 fail(runString, t); | |
20765 return; | |
20766 } | |
20767 pass(); | |
20768 } | |
20769 | |
20770 static void jtt_reflect_Array_get03() { | |
20771 begin("jtt.reflect.Array_get03"); | |
20772 String runString = null; | |
20773 try { | |
20774 // (0) == 11 | |
20775 runString = "(0)"; | |
20776 if ((byte) 11 != jtt.reflect.Array_get03.test(0)) { | |
20777 fail(runString); | |
20778 return; | |
20779 } | |
20780 // (1) == 21 | |
20781 runString = "(1)"; | |
20782 if ((byte) 21 != jtt.reflect.Array_get03.test(1)) { | |
20783 fail(runString); | |
20784 return; | |
20785 } | |
20786 // (2) == 42 | |
20787 runString = "(2)"; | |
20788 if ((byte) 42 != jtt.reflect.Array_get03.test(2)) { | |
20789 fail(runString); | |
20790 return; | |
20791 } | |
20792 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20793 try { | |
20794 runString = "(3)"; | |
20795 jtt.reflect.Array_get03.test(3); | |
20796 fail(runString); | |
20797 return; | |
20798 } catch (Throwable e) { | |
20799 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20800 fail(runString, e); | |
20801 return; | |
20802 } | |
20803 } | |
20804 } catch (Throwable t) { | |
20805 fail(runString, t); | |
20806 return; | |
20807 } | |
20808 pass(); | |
20809 } | |
20810 | |
20811 static void jtt_reflect_Array_getBoolean01() { | |
20812 begin("jtt.reflect.Array_getBoolean01"); | |
20813 String runString = null; | |
20814 try { | |
20815 // (0) == true | |
20816 runString = "(0)"; | |
20817 if (true != jtt.reflect.Array_getBoolean01.test(0)) { | |
20818 fail(runString); | |
20819 return; | |
20820 } | |
20821 // (1) == false | |
20822 runString = "(1)"; | |
20823 if (false != jtt.reflect.Array_getBoolean01.test(1)) { | |
20824 fail(runString); | |
20825 return; | |
20826 } | |
20827 // (2) == true | |
20828 runString = "(2)"; | |
20829 if (true != jtt.reflect.Array_getBoolean01.test(2)) { | |
20830 fail(runString); | |
20831 return; | |
20832 } | |
20833 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20834 try { | |
20835 runString = "(3)"; | |
20836 jtt.reflect.Array_getBoolean01.test(3); | |
20837 fail(runString); | |
20838 return; | |
20839 } catch (Throwable e) { | |
20840 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20841 fail(runString, e); | |
20842 return; | |
20843 } | |
20844 } | |
20845 } catch (Throwable t) { | |
20846 fail(runString, t); | |
20847 return; | |
20848 } | |
20849 pass(); | |
20850 } | |
20851 | |
20852 static void jtt_reflect_Array_getByte01() { | |
20853 begin("jtt.reflect.Array_getByte01"); | |
20854 String runString = null; | |
20855 try { | |
20856 // (0) == 11 | |
20857 runString = "(0)"; | |
20858 if ((byte) 11 != jtt.reflect.Array_getByte01.test(0)) { | |
20859 fail(runString); | |
20860 return; | |
20861 } | |
20862 // (1) == 21 | |
20863 runString = "(1)"; | |
20864 if ((byte) 21 != jtt.reflect.Array_getByte01.test(1)) { | |
20865 fail(runString); | |
20866 return; | |
20867 } | |
20868 // (2) == 42 | |
20869 runString = "(2)"; | |
20870 if ((byte) 42 != jtt.reflect.Array_getByte01.test(2)) { | |
20871 fail(runString); | |
20872 return; | |
20873 } | |
20874 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20875 try { | |
20876 runString = "(3)"; | |
20877 jtt.reflect.Array_getByte01.test(3); | |
20878 fail(runString); | |
20879 return; | |
20880 } catch (Throwable e) { | |
20881 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20882 fail(runString, e); | |
20883 return; | |
20884 } | |
20885 } | |
20886 } catch (Throwable t) { | |
20887 fail(runString, t); | |
20888 return; | |
20889 } | |
20890 pass(); | |
20891 } | |
20892 | |
20893 static void jtt_reflect_Array_getChar01() { | |
20894 begin("jtt.reflect.Array_getChar01"); | |
20895 String runString = null; | |
20896 try { | |
20897 // (0) == '\13' | |
20898 runString = "(0)"; | |
20899 if ((char) 11 != jtt.reflect.Array_getChar01.test(0)) { | |
20900 fail(runString); | |
20901 return; | |
20902 } | |
20903 // (1) == '\25' | |
20904 runString = "(1)"; | |
20905 if ((char) 21 != jtt.reflect.Array_getChar01.test(1)) { | |
20906 fail(runString); | |
20907 return; | |
20908 } | |
20909 // (2) == '*' | |
20910 runString = "(2)"; | |
20911 if ((char) 42 != jtt.reflect.Array_getChar01.test(2)) { | |
20912 fail(runString); | |
20913 return; | |
20914 } | |
20915 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20916 try { | |
20917 runString = "(3)"; | |
20918 jtt.reflect.Array_getChar01.test(3); | |
20919 fail(runString); | |
20920 return; | |
20921 } catch (Throwable e) { | |
20922 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20923 fail(runString, e); | |
20924 return; | |
20925 } | |
20926 } | |
20927 } catch (Throwable t) { | |
20928 fail(runString, t); | |
20929 return; | |
20930 } | |
20931 pass(); | |
20932 } | |
20933 | |
20934 static void jtt_reflect_Array_getDouble01() { | |
20935 begin("jtt.reflect.Array_getDouble01"); | |
20936 String runString = null; | |
20937 try { | |
20938 // (0) == 11.1 | |
20939 runString = "(0)"; | |
20940 if (11.1 != jtt.reflect.Array_getDouble01.test(0)) { | |
20941 fail(runString); | |
20942 return; | |
20943 } | |
20944 // (1) == 21.1 | |
20945 runString = "(1)"; | |
20946 if (21.1 != jtt.reflect.Array_getDouble01.test(1)) { | |
20947 fail(runString); | |
20948 return; | |
20949 } | |
20950 // (2) == 42.1 | |
20951 runString = "(2)"; | |
20952 if (42.1 != jtt.reflect.Array_getDouble01.test(2)) { | |
20953 fail(runString); | |
20954 return; | |
20955 } | |
20956 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20957 try { | |
20958 runString = "(3)"; | |
20959 jtt.reflect.Array_getDouble01.test(3); | |
20960 fail(runString); | |
20961 return; | |
20962 } catch (Throwable e) { | |
20963 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
20964 fail(runString, e); | |
20965 return; | |
20966 } | |
20967 } | |
20968 } catch (Throwable t) { | |
20969 fail(runString, t); | |
20970 return; | |
20971 } | |
20972 pass(); | |
20973 } | |
20974 | |
20975 static void jtt_reflect_Array_getFloat01() { | |
20976 begin("jtt.reflect.Array_getFloat01"); | |
20977 String runString = null; | |
20978 try { | |
20979 // (0) == 11.1 | |
20980 runString = "(0)"; | |
20981 if (11.1f != jtt.reflect.Array_getFloat01.test(0)) { | |
20982 fail(runString); | |
20983 return; | |
20984 } | |
20985 // (1) == 21.1 | |
20986 runString = "(1)"; | |
20987 if (21.1f != jtt.reflect.Array_getFloat01.test(1)) { | |
20988 fail(runString); | |
20989 return; | |
20990 } | |
20991 // (2) == 42.1 | |
20992 runString = "(2)"; | |
20993 if (42.1f != jtt.reflect.Array_getFloat01.test(2)) { | |
20994 fail(runString); | |
20995 return; | |
20996 } | |
20997 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
20998 try { | |
20999 runString = "(3)"; | |
21000 jtt.reflect.Array_getFloat01.test(3); | |
21001 fail(runString); | |
21002 return; | |
21003 } catch (Throwable e) { | |
21004 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21005 fail(runString, e); | |
21006 return; | |
21007 } | |
21008 } | |
21009 } catch (Throwable t) { | |
21010 fail(runString, t); | |
21011 return; | |
21012 } | |
21013 pass(); | |
21014 } | |
21015 | |
21016 static void jtt_reflect_Array_getInt01() { | |
21017 begin("jtt.reflect.Array_getInt01"); | |
21018 String runString = null; | |
21019 try { | |
21020 // (0) == 11 | |
21021 runString = "(0)"; | |
21022 if (11 != jtt.reflect.Array_getInt01.test(0)) { | |
21023 fail(runString); | |
21024 return; | |
21025 } | |
21026 // (1) == 21 | |
21027 runString = "(1)"; | |
21028 if (21 != jtt.reflect.Array_getInt01.test(1)) { | |
21029 fail(runString); | |
21030 return; | |
21031 } | |
21032 // (2) == 42 | |
21033 runString = "(2)"; | |
21034 if (42 != jtt.reflect.Array_getInt01.test(2)) { | |
21035 fail(runString); | |
21036 return; | |
21037 } | |
21038 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
21039 try { | |
21040 runString = "(3)"; | |
21041 jtt.reflect.Array_getInt01.test(3); | |
21042 fail(runString); | |
21043 return; | |
21044 } catch (Throwable e) { | |
21045 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21046 fail(runString, e); | |
21047 return; | |
21048 } | |
21049 } | |
21050 } catch (Throwable t) { | |
21051 fail(runString, t); | |
21052 return; | |
21053 } | |
21054 pass(); | |
21055 } | |
21056 | |
21057 static void jtt_reflect_Array_getLength01() { | |
21058 begin("jtt.reflect.Array_getLength01"); | |
21059 String runString = null; | |
21060 try { | |
21061 // (0) == 3 | |
21062 runString = "(0)"; | |
21063 if (3 != jtt.reflect.Array_getLength01.test(0)) { | |
21064 fail(runString); | |
21065 return; | |
21066 } | |
21067 // (1) == 4 | |
21068 runString = "(1)"; | |
21069 if (4 != jtt.reflect.Array_getLength01.test(1)) { | |
21070 fail(runString); | |
21071 return; | |
21072 } | |
21073 // (2) == 1 | |
21074 runString = "(2)"; | |
21075 if (1 != jtt.reflect.Array_getLength01.test(2)) { | |
21076 fail(runString); | |
21077 return; | |
21078 } | |
21079 // (3) == !java.lang.NullPointerException | |
21080 try { | |
21081 runString = "(3)"; | |
21082 jtt.reflect.Array_getLength01.test(3); | |
21083 fail(runString); | |
21084 return; | |
21085 } catch (Throwable e) { | |
21086 if (e.getClass() != java.lang.NullPointerException.class) { | |
21087 fail(runString, e); | |
21088 return; | |
21089 } | |
21090 } | |
21091 } catch (Throwable t) { | |
21092 fail(runString, t); | |
21093 return; | |
21094 } | |
21095 pass(); | |
21096 } | |
21097 | |
21098 static void jtt_reflect_Array_getLong01() { | |
21099 begin("jtt.reflect.Array_getLong01"); | |
21100 String runString = null; | |
21101 try { | |
21102 // (0) == 11 | |
21103 runString = "(0)"; | |
21104 if (11L != jtt.reflect.Array_getLong01.test(0)) { | |
21105 fail(runString); | |
21106 return; | |
21107 } | |
21108 // (1) == 21 | |
21109 runString = "(1)"; | |
21110 if (21L != jtt.reflect.Array_getLong01.test(1)) { | |
21111 fail(runString); | |
21112 return; | |
21113 } | |
21114 // (2) == 42 | |
21115 runString = "(2)"; | |
21116 if (42L != jtt.reflect.Array_getLong01.test(2)) { | |
21117 fail(runString); | |
21118 return; | |
21119 } | |
21120 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
21121 try { | |
21122 runString = "(3)"; | |
21123 jtt.reflect.Array_getLong01.test(3); | |
21124 fail(runString); | |
21125 return; | |
21126 } catch (Throwable e) { | |
21127 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21128 fail(runString, e); | |
21129 return; | |
21130 } | |
21131 } | |
21132 } catch (Throwable t) { | |
21133 fail(runString, t); | |
21134 return; | |
21135 } | |
21136 pass(); | |
21137 } | |
21138 | |
21139 static void jtt_reflect_Array_getShort01() { | |
21140 begin("jtt.reflect.Array_getShort01"); | |
21141 String runString = null; | |
21142 try { | |
21143 // (0) == 11 | |
21144 runString = "(0)"; | |
21145 if ((short) 11 != jtt.reflect.Array_getShort01.test(0)) { | |
21146 fail(runString); | |
21147 return; | |
21148 } | |
21149 // (1) == 21 | |
21150 runString = "(1)"; | |
21151 if ((short) 21 != jtt.reflect.Array_getShort01.test(1)) { | |
21152 fail(runString); | |
21153 return; | |
21154 } | |
21155 // (2) == 42 | |
21156 runString = "(2)"; | |
21157 if ((short) 42 != jtt.reflect.Array_getShort01.test(2)) { | |
21158 fail(runString); | |
21159 return; | |
21160 } | |
21161 // (3) == !java.lang.ArrayIndexOutOfBoundsException | |
21162 try { | |
21163 runString = "(3)"; | |
21164 jtt.reflect.Array_getShort01.test(3); | |
21165 fail(runString); | |
21166 return; | |
21167 } catch (Throwable e) { | |
21168 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21169 fail(runString, e); | |
21170 return; | |
21171 } | |
21172 } | |
21173 } catch (Throwable t) { | |
21174 fail(runString, t); | |
21175 return; | |
21176 } | |
21177 pass(); | |
21178 } | |
21179 | |
21180 static void jtt_reflect_Array_newInstance01() { | |
21181 begin("jtt.reflect.Array_newInstance01"); | |
21182 String runString = null; | |
21183 try { | |
21184 // (1) == true | |
21185 runString = "(1)"; | |
21186 if (true != jtt.reflect.Array_newInstance01.test(1)) { | |
21187 fail(runString); | |
21188 return; | |
21189 } | |
21190 } catch (Throwable t) { | |
21191 fail(runString, t); | |
21192 return; | |
21193 } | |
21194 pass(); | |
21195 } | |
21196 | |
21197 static void jtt_reflect_Array_newInstance02() { | |
21198 begin("jtt.reflect.Array_newInstance02"); | |
21199 String runString = null; | |
21200 try { | |
21201 // (1) == true | |
21202 runString = "(1)"; | |
21203 if (true != jtt.reflect.Array_newInstance02.test(1)) { | |
21204 fail(runString); | |
21205 return; | |
21206 } | |
21207 } catch (Throwable t) { | |
21208 fail(runString, t); | |
21209 return; | |
21210 } | |
21211 pass(); | |
21212 } | |
21213 | |
21214 static void jtt_reflect_Array_newInstance03() { | |
21215 begin("jtt.reflect.Array_newInstance03"); | |
21216 String runString = null; | |
21217 try { | |
21218 // (1) == true | |
21219 runString = "(1)"; | |
21220 if (true != jtt.reflect.Array_newInstance03.test(1)) { | |
21221 fail(runString); | |
21222 return; | |
21223 } | |
21224 } catch (Throwable t) { | |
21225 fail(runString, t); | |
21226 return; | |
21227 } | |
21228 pass(); | |
21229 } | |
21230 | |
21231 static void jtt_reflect_Array_newInstance04() { | |
21232 begin("jtt.reflect.Array_newInstance04"); | |
21233 String runString = null; | |
21234 try { | |
21235 // (1,0) == true | |
21236 runString = "(1,0)"; | |
21237 if (true != jtt.reflect.Array_newInstance04.test(1, 0)) { | |
21238 fail(runString); | |
21239 return; | |
21240 } | |
21241 } catch (Throwable t) { | |
21242 fail(runString, t); | |
21243 return; | |
21244 } | |
21245 pass(); | |
21246 } | |
21247 | |
21248 static void jtt_reflect_Array_newInstance05() { | |
21249 begin("jtt.reflect.Array_newInstance05"); | |
21250 String runString = null; | |
21251 try { | |
21252 // (1,3) == true | |
21253 runString = "(1,3)"; | |
21254 if (true != jtt.reflect.Array_newInstance05.test(1, 3)) { | |
21255 fail(runString); | |
21256 return; | |
21257 } | |
21258 } catch (Throwable t) { | |
21259 fail(runString, t); | |
21260 return; | |
21261 } | |
21262 pass(); | |
21263 } | |
21264 | |
21265 static void jtt_reflect_Array_newInstance06() { | |
21266 begin("jtt.reflect.Array_newInstance06"); | |
21267 String runString = null; | |
21268 try { | |
21269 // (1) == true | |
21270 runString = "(1)"; | |
21271 if (true != jtt.reflect.Array_newInstance06.test(1)) { | |
21272 fail(runString); | |
21273 return; | |
21274 } | |
21275 } catch (Throwable t) { | |
21276 fail(runString, t); | |
21277 return; | |
21278 } | |
21279 pass(); | |
21280 } | |
21281 | |
21282 static void jtt_reflect_Array_set01() { | |
21283 begin("jtt.reflect.Array_set01"); | |
21284 String runString = null; | |
21285 try { | |
21286 // (0,"1") == "1" | |
21287 runString = "(0,\"1\")"; | |
21288 if (!"1".equals(jtt.reflect.Array_set01.test(0, "1"))) { | |
21289 fail(runString); | |
21290 return; | |
21291 } | |
21292 // (1,"2") == "2" | |
21293 runString = "(1,\"2\")"; | |
21294 if (!"2".equals(jtt.reflect.Array_set01.test(1, "2"))) { | |
21295 fail(runString); | |
21296 return; | |
21297 } | |
21298 // (0,"XXd") == "XXd" | |
21299 runString = "(0,\"XXd\")"; | |
21300 if (!"XXd".equals(jtt.reflect.Array_set01.test(0, "XXd"))) { | |
21301 fail(runString); | |
21302 return; | |
21303 } | |
21304 // (3,"--") == !java.lang.ArrayIndexOutOfBoundsException | |
21305 try { | |
21306 runString = "(3,\"--\")"; | |
21307 jtt.reflect.Array_set01.test(3, "--"); | |
21308 fail(runString); | |
21309 return; | |
21310 } catch (Throwable e) { | |
21311 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21312 fail(runString, e); | |
21313 return; | |
21314 } | |
21315 } | |
21316 } catch (Throwable t) { | |
21317 fail(runString, t); | |
21318 return; | |
21319 } | |
21320 pass(); | |
21321 } | |
21322 | |
21323 static void jtt_reflect_Array_set02() { | |
21324 begin("jtt.reflect.Array_set02"); | |
21325 String runString = null; | |
21326 try { | |
21327 // (0,11) == 11 | |
21328 runString = "(0,11)"; | |
21329 if (11 != jtt.reflect.Array_set02.test(0, 11)) { | |
21330 fail(runString); | |
21331 return; | |
21332 } | |
21333 // (1,21) == 21 | |
21334 runString = "(1,21)"; | |
21335 if (21 != jtt.reflect.Array_set02.test(1, 21)) { | |
21336 fail(runString); | |
21337 return; | |
21338 } | |
21339 // (0,42) == 42 | |
21340 runString = "(0,42)"; | |
21341 if (42 != jtt.reflect.Array_set02.test(0, 42)) { | |
21342 fail(runString); | |
21343 return; | |
21344 } | |
21345 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException | |
21346 try { | |
21347 runString = "(3,0)"; | |
21348 jtt.reflect.Array_set02.test(3, 0); | |
21349 fail(runString); | |
21350 return; | |
21351 } catch (Throwable e) { | |
21352 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21353 fail(runString, e); | |
21354 return; | |
21355 } | |
21356 } | |
21357 } catch (Throwable t) { | |
21358 fail(runString, t); | |
21359 return; | |
21360 } | |
21361 pass(); | |
21362 } | |
21363 | |
21364 static void jtt_reflect_Array_set03() { | |
21365 begin("jtt.reflect.Array_set03"); | |
21366 String runString = null; | |
21367 try { | |
21368 // (0,11) == 11 | |
21369 runString = "(0,11)"; | |
21370 if ((byte) 11 != jtt.reflect.Array_set03.test(0, (byte) 11)) { | |
21371 fail(runString); | |
21372 return; | |
21373 } | |
21374 // (1,21) == 21 | |
21375 runString = "(1,21)"; | |
21376 if ((byte) 21 != jtt.reflect.Array_set03.test(1, (byte) 21)) { | |
21377 fail(runString); | |
21378 return; | |
21379 } | |
21380 // (0,42) == 42 | |
21381 runString = "(0,42)"; | |
21382 if ((byte) 42 != jtt.reflect.Array_set03.test(0, (byte) 42)) { | |
21383 fail(runString); | |
21384 return; | |
21385 } | |
21386 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException | |
21387 try { | |
21388 runString = "(3,0)"; | |
21389 jtt.reflect.Array_set03.test(3, (byte) 0); | |
21390 fail(runString); | |
21391 return; | |
21392 } catch (Throwable e) { | |
21393 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21394 fail(runString, e); | |
21395 return; | |
21396 } | |
21397 } | |
21398 } catch (Throwable t) { | |
21399 fail(runString, t); | |
21400 return; | |
21401 } | |
21402 pass(); | |
21403 } | |
21404 | |
21405 static void jtt_reflect_Array_setBoolean01() { | |
21406 begin("jtt.reflect.Array_setBoolean01"); | |
21407 String runString = null; | |
21408 try { | |
21409 // (0,true) == true | |
21410 runString = "(0,true)"; | |
21411 if (true != jtt.reflect.Array_setBoolean01.test(0, true)) { | |
21412 fail(runString); | |
21413 return; | |
21414 } | |
21415 // (1,false) == false | |
21416 runString = "(1,false)"; | |
21417 if (false != jtt.reflect.Array_setBoolean01.test(1, false)) { | |
21418 fail(runString); | |
21419 return; | |
21420 } | |
21421 // (2,true) == true | |
21422 runString = "(2,true)"; | |
21423 if (true != jtt.reflect.Array_setBoolean01.test(2, true)) { | |
21424 fail(runString); | |
21425 return; | |
21426 } | |
21427 // (3,false) == !java.lang.ArrayIndexOutOfBoundsException | |
21428 try { | |
21429 runString = "(3,false)"; | |
21430 jtt.reflect.Array_setBoolean01.test(3, false); | |
21431 fail(runString); | |
21432 return; | |
21433 } catch (Throwable e) { | |
21434 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21435 fail(runString, e); | |
21436 return; | |
21437 } | |
21438 } | |
21439 } catch (Throwable t) { | |
21440 fail(runString, t); | |
21441 return; | |
21442 } | |
21443 pass(); | |
21444 } | |
21445 | |
21446 static void jtt_reflect_Array_setByte01() { | |
21447 begin("jtt.reflect.Array_setByte01"); | |
21448 String runString = null; | |
21449 try { | |
21450 // (0,11) == 11 | |
21451 runString = "(0,11)"; | |
21452 if ((byte) 11 != jtt.reflect.Array_setByte01.test(0, (byte) 11)) { | |
21453 fail(runString); | |
21454 return; | |
21455 } | |
21456 // (1,21) == 21 | |
21457 runString = "(1,21)"; | |
21458 if ((byte) 21 != jtt.reflect.Array_setByte01.test(1, (byte) 21)) { | |
21459 fail(runString); | |
21460 return; | |
21461 } | |
21462 // (0,42) == 42 | |
21463 runString = "(0,42)"; | |
21464 if ((byte) 42 != jtt.reflect.Array_setByte01.test(0, (byte) 42)) { | |
21465 fail(runString); | |
21466 return; | |
21467 } | |
21468 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException | |
21469 try { | |
21470 runString = "(3,0)"; | |
21471 jtt.reflect.Array_setByte01.test(3, (byte) 0); | |
21472 fail(runString); | |
21473 return; | |
21474 } catch (Throwable e) { | |
21475 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21476 fail(runString, e); | |
21477 return; | |
21478 } | |
21479 } | |
21480 } catch (Throwable t) { | |
21481 fail(runString, t); | |
21482 return; | |
21483 } | |
21484 pass(); | |
21485 } | |
21486 | |
21487 static void jtt_reflect_Array_setChar01() { | |
21488 begin("jtt.reflect.Array_setChar01"); | |
21489 String runString = null; | |
21490 try { | |
21491 // (0,'\13') == '\13' | |
21492 runString = "(0,'\13')"; | |
21493 if ((char) 11 != jtt.reflect.Array_setChar01.test(0, (char) 11)) { | |
21494 fail(runString); | |
21495 return; | |
21496 } | |
21497 // (1,'\25') == '\25' | |
21498 runString = "(1,'\25')"; | |
21499 if ((char) 21 != jtt.reflect.Array_setChar01.test(1, (char) 21)) { | |
21500 fail(runString); | |
21501 return; | |
21502 } | |
21503 // (0,'*') == '*' | |
21504 runString = "(0,'*')"; | |
21505 if ((char) 42 != jtt.reflect.Array_setChar01.test(0, (char) 42)) { | |
21506 fail(runString); | |
21507 return; | |
21508 } | |
21509 // (3,'\0') == !java.lang.ArrayIndexOutOfBoundsException | |
21510 try { | |
21511 runString = "(3,'\0')"; | |
21512 jtt.reflect.Array_setChar01.test(3, (char) 0); | |
21513 fail(runString); | |
21514 return; | |
21515 } catch (Throwable e) { | |
21516 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21517 fail(runString, e); | |
21518 return; | |
21519 } | |
21520 } | |
21521 } catch (Throwable t) { | |
21522 fail(runString, t); | |
21523 return; | |
21524 } | |
21525 pass(); | |
21526 } | |
21527 | |
21528 static void jtt_reflect_Array_setDouble01() { | |
21529 begin("jtt.reflect.Array_setDouble01"); | |
21530 String runString = null; | |
21531 try { | |
21532 // (0,11.1) == 11.1 | |
21533 runString = "(0,11.1)"; | |
21534 if (11.1 != jtt.reflect.Array_setDouble01.test(0, 11.1)) { | |
21535 fail(runString); | |
21536 return; | |
21537 } | |
21538 // (1,21.1) == 21.1 | |
21539 runString = "(1,21.1)"; | |
21540 if (21.1 != jtt.reflect.Array_setDouble01.test(1, 21.1)) { | |
21541 fail(runString); | |
21542 return; | |
21543 } | |
21544 // (0,42.1) == 42.1 | |
21545 runString = "(0,42.1)"; | |
21546 if (42.1 != jtt.reflect.Array_setDouble01.test(0, 42.1)) { | |
21547 fail(runString); | |
21548 return; | |
21549 } | |
21550 // (3,0.1) == !java.lang.ArrayIndexOutOfBoundsException | |
21551 try { | |
21552 runString = "(3,0.1)"; | |
21553 jtt.reflect.Array_setDouble01.test(3, 0.1); | |
21554 fail(runString); | |
21555 return; | |
21556 } catch (Throwable e) { | |
21557 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21558 fail(runString, e); | |
21559 return; | |
21560 } | |
21561 } | |
21562 } catch (Throwable t) { | |
21563 fail(runString, t); | |
21564 return; | |
21565 } | |
21566 pass(); | |
21567 } | |
21568 | |
21569 static void jtt_reflect_Array_setFloat01() { | |
21570 begin("jtt.reflect.Array_setFloat01"); | |
21571 String runString = null; | |
21572 try { | |
21573 // (0,11.1) == 11.1 | |
21574 runString = "(0,11.1)"; | |
21575 if (11.1f != jtt.reflect.Array_setFloat01.test(0, 11.1f)) { | |
21576 fail(runString); | |
21577 return; | |
21578 } | |
21579 // (1,21.1) == 21.1 | |
21580 runString = "(1,21.1)"; | |
21581 if (21.1f != jtt.reflect.Array_setFloat01.test(1, 21.1f)) { | |
21582 fail(runString); | |
21583 return; | |
21584 } | |
21585 // (0,42.1) == 42.1 | |
21586 runString = "(0,42.1)"; | |
21587 if (42.1f != jtt.reflect.Array_setFloat01.test(0, 42.1f)) { | |
21588 fail(runString); | |
21589 return; | |
21590 } | |
21591 // (3,0.1) == !java.lang.ArrayIndexOutOfBoundsException | |
21592 try { | |
21593 runString = "(3,0.1)"; | |
21594 jtt.reflect.Array_setFloat01.test(3, 0.1f); | |
21595 fail(runString); | |
21596 return; | |
21597 } catch (Throwable e) { | |
21598 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21599 fail(runString, e); | |
21600 return; | |
21601 } | |
21602 } | |
21603 } catch (Throwable t) { | |
21604 fail(runString, t); | |
21605 return; | |
21606 } | |
21607 pass(); | |
21608 } | |
21609 | |
21610 static void jtt_reflect_Array_setInt01() { | |
21611 begin("jtt.reflect.Array_setInt01"); | |
21612 String runString = null; | |
21613 try { | |
21614 // (0,11) == 11 | |
21615 runString = "(0,11)"; | |
21616 if (11 != jtt.reflect.Array_setInt01.test(0, 11)) { | |
21617 fail(runString); | |
21618 return; | |
21619 } | |
21620 // (1,21) == 21 | |
21621 runString = "(1,21)"; | |
21622 if (21 != jtt.reflect.Array_setInt01.test(1, 21)) { | |
21623 fail(runString); | |
21624 return; | |
21625 } | |
21626 // (0,42) == 42 | |
21627 runString = "(0,42)"; | |
21628 if (42 != jtt.reflect.Array_setInt01.test(0, 42)) { | |
21629 fail(runString); | |
21630 return; | |
21631 } | |
21632 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException | |
21633 try { | |
21634 runString = "(3,0)"; | |
21635 jtt.reflect.Array_setInt01.test(3, 0); | |
21636 fail(runString); | |
21637 return; | |
21638 } catch (Throwable e) { | |
21639 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21640 fail(runString, e); | |
21641 return; | |
21642 } | |
21643 } | |
21644 } catch (Throwable t) { | |
21645 fail(runString, t); | |
21646 return; | |
21647 } | |
21648 pass(); | |
21649 } | |
21650 | |
21651 static void jtt_reflect_Array_setLong01() { | |
21652 begin("jtt.reflect.Array_setLong01"); | |
21653 String runString = null; | |
21654 try { | |
21655 // (0,11) == 11 | |
21656 runString = "(0,11)"; | |
21657 if (11L != jtt.reflect.Array_setLong01.test(0, 11L)) { | |
21658 fail(runString); | |
21659 return; | |
21660 } | |
21661 // (1,21) == 21 | |
21662 runString = "(1,21)"; | |
21663 if (21L != jtt.reflect.Array_setLong01.test(1, 21L)) { | |
21664 fail(runString); | |
21665 return; | |
21666 } | |
21667 // (0,42) == 42 | |
21668 runString = "(0,42)"; | |
21669 if (42L != jtt.reflect.Array_setLong01.test(0, 42L)) { | |
21670 fail(runString); | |
21671 return; | |
21672 } | |
21673 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException | |
21674 try { | |
21675 runString = "(3,0)"; | |
21676 jtt.reflect.Array_setLong01.test(3, 0L); | |
21677 fail(runString); | |
21678 return; | |
21679 } catch (Throwable e) { | |
21680 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21681 fail(runString, e); | |
21682 return; | |
21683 } | |
21684 } | |
21685 } catch (Throwable t) { | |
21686 fail(runString, t); | |
21687 return; | |
21688 } | |
21689 pass(); | |
21690 } | |
21691 | |
21692 static void jtt_reflect_Array_setShort01() { | |
21693 begin("jtt.reflect.Array_setShort01"); | |
21694 String runString = null; | |
21695 try { | |
21696 // (0,11) == 11 | |
21697 runString = "(0,11)"; | |
21698 if ((short) 11 != jtt.reflect.Array_setShort01.test(0, (short) 11)) { | |
21699 fail(runString); | |
21700 return; | |
21701 } | |
21702 // (1,21) == 21 | |
21703 runString = "(1,21)"; | |
21704 if ((short) 21 != jtt.reflect.Array_setShort01.test(1, (short) 21)) { | |
21705 fail(runString); | |
21706 return; | |
21707 } | |
21708 // (0,42) == 42 | |
21709 runString = "(0,42)"; | |
21710 if ((short) 42 != jtt.reflect.Array_setShort01.test(0, (short) 42)) { | |
21711 fail(runString); | |
21712 return; | |
21713 } | |
21714 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException | |
21715 try { | |
21716 runString = "(3,0)"; | |
21717 jtt.reflect.Array_setShort01.test(3, (short) 0); | |
21718 fail(runString); | |
21719 return; | |
21720 } catch (Throwable e) { | |
21721 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) { | |
21722 fail(runString, e); | |
21723 return; | |
21724 } | |
21725 } | |
21726 } catch (Throwable t) { | |
21727 fail(runString, t); | |
21728 return; | |
21729 } | |
21730 pass(); | |
21731 } | |
21732 | |
21733 static void jtt_reflect_Class_getDeclaredField01() { | |
21734 begin("jtt.reflect.Class_getDeclaredField01"); | |
21735 String runString = null; | |
21736 try { | |
21737 // ("test") == !java.lang.NoSuchFieldException | |
21738 try { | |
21739 runString = "(\"test\")"; | |
21740 jtt.reflect.Class_getDeclaredField01.test("test"); | |
21741 fail(runString); | |
21742 return; | |
21743 } catch (Throwable e) { | |
21744 if (e.getClass() != java.lang.NoSuchFieldException.class) { | |
21745 fail(runString, e); | |
21746 return; | |
21747 } | |
21748 } | |
21749 // ("field") == "field" | |
21750 runString = "(\"field\")"; | |
21751 if (!"field".equals(jtt.reflect.Class_getDeclaredField01 | |
21752 .test("field"))) { | |
21753 fail(runString); | |
21754 return; | |
21755 } | |
21756 // ("f2") == "f2" | |
21757 runString = "(\"f2\")"; | |
21758 if (!"f2".equals(jtt.reflect.Class_getDeclaredField01.test("f2"))) { | |
21759 fail(runString); | |
21760 return; | |
21761 } | |
21762 } catch (Throwable t) { | |
21763 fail(runString, t); | |
21764 return; | |
21765 } | |
21766 pass(); | |
21767 } | |
21768 | |
21769 static void jtt_reflect_Class_getDeclaredMethod01() { | |
21770 begin("jtt.reflect.Class_getDeclaredMethod01"); | |
21771 String runString = null; | |
21772 try { | |
21773 // ("test") == !java.lang.NoSuchMethodException | |
21774 try { | |
21775 runString = "(\"test\")"; | |
21776 jtt.reflect.Class_getDeclaredMethod01.test("test"); | |
21777 fail(runString); | |
21778 return; | |
21779 } catch (Throwable e) { | |
21780 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
21781 fail(runString, e); | |
21782 return; | |
21783 } | |
21784 } | |
21785 // ("main") == "main" | |
21786 runString = "(\"main\")"; | |
21787 if (!"main".equals(jtt.reflect.Class_getDeclaredMethod01 | |
21788 .test("main"))) { | |
21789 fail(runString); | |
21790 return; | |
21791 } | |
21792 // ("xx") == !java.lang.NoSuchMethodException | |
21793 try { | |
21794 runString = "(\"xx\")"; | |
21795 jtt.reflect.Class_getDeclaredMethod01.test("xx"); | |
21796 fail(runString); | |
21797 return; | |
21798 } catch (Throwable e) { | |
21799 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
21800 fail(runString, e); | |
21801 return; | |
21802 } | |
21803 } | |
21804 } catch (Throwable t) { | |
21805 fail(runString, t); | |
21806 return; | |
21807 } | |
21808 pass(); | |
21809 } | |
21810 | |
21811 static void jtt_reflect_Class_getField01() { | |
21812 begin("jtt.reflect.Class_getField01"); | |
21813 String runString = null; | |
21814 try { | |
21815 // ("test") == !java.lang.NoSuchFieldException | |
21816 try { | |
21817 runString = "(\"test\")"; | |
21818 jtt.reflect.Class_getField01.test("test"); | |
21819 fail(runString); | |
21820 return; | |
21821 } catch (Throwable e) { | |
21822 if (e.getClass() != java.lang.NoSuchFieldException.class) { | |
21823 fail(runString, e); | |
21824 return; | |
21825 } | |
21826 } | |
21827 // ("field") == "field" | |
21828 runString = "(\"field\")"; | |
21829 if (!"field".equals(jtt.reflect.Class_getField01.test("field"))) { | |
21830 fail(runString); | |
21831 return; | |
21832 } | |
21833 // ("field2") == "field2" | |
21834 runString = "(\"field2\")"; | |
21835 if (!"field2".equals(jtt.reflect.Class_getField01.test("field2"))) { | |
21836 fail(runString); | |
21837 return; | |
21838 } | |
21839 // ("field3") == !java.lang.NoSuchFieldException | |
21840 try { | |
21841 runString = "(\"field3\")"; | |
21842 jtt.reflect.Class_getField01.test("field3"); | |
21843 fail(runString); | |
21844 return; | |
21845 } catch (Throwable e) { | |
21846 if (e.getClass() != java.lang.NoSuchFieldException.class) { | |
21847 fail(runString, e); | |
21848 return; | |
21849 } | |
21850 } | |
21851 } catch (Throwable t) { | |
21852 fail(runString, t); | |
21853 return; | |
21854 } | |
21855 pass(); | |
21856 } | |
21857 | |
21858 static void jtt_reflect_Class_getField02() { | |
21859 begin("jtt.reflect.Class_getField02"); | |
21860 String runString = null; | |
21861 try { | |
21862 // ("test") == !java.lang.NoSuchFieldException | |
21863 try { | |
21864 runString = "(\"test\")"; | |
21865 jtt.reflect.Class_getField02.test("test"); | |
21866 fail(runString); | |
21867 return; | |
21868 } catch (Throwable e) { | |
21869 if (e.getClass() != java.lang.NoSuchFieldException.class) { | |
21870 fail(runString, e); | |
21871 return; | |
21872 } | |
21873 } | |
21874 // ("field") == "field" | |
21875 runString = "(\"field\")"; | |
21876 if (!"field".equals(jtt.reflect.Class_getField02.test("field"))) { | |
21877 fail(runString); | |
21878 return; | |
21879 } | |
21880 // ("field2") == "field2" | |
21881 runString = "(\"field2\")"; | |
21882 if (!"field2".equals(jtt.reflect.Class_getField02.test("field2"))) { | |
21883 fail(runString); | |
21884 return; | |
21885 } | |
21886 // ("field3") == !java.lang.NoSuchFieldException | |
21887 try { | |
21888 runString = "(\"field3\")"; | |
21889 jtt.reflect.Class_getField02.test("field3"); | |
21890 fail(runString); | |
21891 return; | |
21892 } catch (Throwable e) { | |
21893 if (e.getClass() != java.lang.NoSuchFieldException.class) { | |
21894 fail(runString, e); | |
21895 return; | |
21896 } | |
21897 } | |
21898 // ("field4") == "field4" | |
21899 runString = "(\"field4\")"; | |
21900 if (!"field4".equals(jtt.reflect.Class_getField02.test("field4"))) { | |
21901 fail(runString); | |
21902 return; | |
21903 } | |
21904 } catch (Throwable t) { | |
21905 fail(runString, t); | |
21906 return; | |
21907 } | |
21908 pass(); | |
21909 } | |
21910 | |
21911 static void jtt_reflect_Class_getMethod01() { | |
21912 begin("jtt.reflect.Class_getMethod01"); | |
21913 String runString = null; | |
21914 try { | |
21915 // ("test") == !java.lang.NoSuchMethodException | |
21916 try { | |
21917 runString = "(\"test\")"; | |
21918 jtt.reflect.Class_getMethod01.test("test"); | |
21919 fail(runString); | |
21920 return; | |
21921 } catch (Throwable e) { | |
21922 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
21923 fail(runString, e); | |
21924 return; | |
21925 } | |
21926 } | |
21927 // ("main") == "main" | |
21928 runString = "(\"main\")"; | |
21929 if (!"main".equals(jtt.reflect.Class_getMethod01.test("main"))) { | |
21930 fail(runString); | |
21931 return; | |
21932 } | |
21933 // ("xx") == !java.lang.NoSuchMethodException | |
21934 try { | |
21935 runString = "(\"xx\")"; | |
21936 jtt.reflect.Class_getMethod01.test("xx"); | |
21937 fail(runString); | |
21938 return; | |
21939 } catch (Throwable e) { | |
21940 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
21941 fail(runString, e); | |
21942 return; | |
21943 } | |
21944 } | |
21945 } catch (Throwable t) { | |
21946 fail(runString, t); | |
21947 return; | |
21948 } | |
21949 pass(); | |
21950 } | |
21951 | |
21952 static void jtt_reflect_Class_getMethod02() { | |
21953 begin("jtt.reflect.Class_getMethod02"); | |
21954 String runString = null; | |
21955 try { | |
21956 // (0) == !java.lang.NoSuchMethodException | |
21957 try { | |
21958 runString = "(0)"; | |
21959 jtt.reflect.Class_getMethod02.test(0); | |
21960 fail(runString); | |
21961 return; | |
21962 } catch (Throwable e) { | |
21963 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
21964 fail(runString, e); | |
21965 return; | |
21966 } | |
21967 } | |
21968 // (1) == "test" | |
21969 runString = "(1)"; | |
21970 if (!"test".equals(jtt.reflect.Class_getMethod02.test(1))) { | |
21971 fail(runString); | |
21972 return; | |
21973 } | |
21974 // (2) == !java.lang.NoSuchMethodException | |
21975 try { | |
21976 runString = "(2)"; | |
21977 jtt.reflect.Class_getMethod02.test(2); | |
21978 fail(runString); | |
21979 return; | |
21980 } catch (Throwable e) { | |
21981 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
21982 fail(runString, e); | |
21983 return; | |
21984 } | |
21985 } | |
21986 // (3) == "main" | |
21987 runString = "(3)"; | |
21988 if (!"main".equals(jtt.reflect.Class_getMethod02.test(3))) { | |
21989 fail(runString); | |
21990 return; | |
21991 } | |
21992 // (4) == !java.lang.NoSuchMethodException | |
21993 try { | |
21994 runString = "(4)"; | |
21995 jtt.reflect.Class_getMethod02.test(4); | |
21996 fail(runString); | |
21997 return; | |
21998 } catch (Throwable e) { | |
21999 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
22000 fail(runString, e); | |
22001 return; | |
22002 } | |
22003 } | |
22004 // (5) == !java.lang.NoSuchMethodException | |
22005 try { | |
22006 runString = "(5)"; | |
22007 jtt.reflect.Class_getMethod02.test(5); | |
22008 fail(runString); | |
22009 return; | |
22010 } catch (Throwable e) { | |
22011 if (e.getClass() != java.lang.NoSuchMethodException.class) { | |
22012 fail(runString, e); | |
22013 return; | |
22014 } | |
22015 } | |
22016 // (6) == null | |
22017 runString = "(6)"; | |
22018 if (null != jtt.reflect.Class_getMethod02.test(6)) { | |
22019 fail(runString); | |
22020 return; | |
22021 } | |
22022 } catch (Throwable t) { | |
22023 fail(runString, t); | |
22024 return; | |
22025 } | |
22026 pass(); | |
22027 } | |
22028 | |
22029 static void jtt_reflect_Class_newInstance01() { | |
22030 begin("jtt.reflect.Class_newInstance01"); | |
22031 String runString = null; | |
22032 try { | |
22033 // (0) == true | |
22034 runString = "(0)"; | |
22035 if (true != jtt.reflect.Class_newInstance01.test(0)) { | |
22036 fail(runString); | |
22037 return; | |
22038 } | |
22039 // (1) == false | |
22040 runString = "(1)"; | |
22041 if (false != jtt.reflect.Class_newInstance01.test(1)) { | |
22042 fail(runString); | |
22043 return; | |
22044 } | |
22045 } catch (Throwable t) { | |
22046 fail(runString, t); | |
22047 return; | |
22048 } | |
22049 pass(); | |
22050 } | |
22051 | |
22052 static void jtt_reflect_Class_newInstance02() { | |
22053 begin("jtt.reflect.Class_newInstance02"); | |
22054 String runString = null; | |
22055 try { | |
22056 // (0) == !java.lang.IllegalAccessException | |
22057 try { | |
22058 runString = "(0)"; | |
22059 jtt.reflect.Class_newInstance02.test(0); | |
22060 fail(runString); | |
22061 return; | |
22062 } catch (Throwable e) { | |
22063 if (e.getClass() != java.lang.IllegalAccessException.class) { | |
22064 fail(runString, e); | |
22065 return; | |
22066 } | |
22067 } | |
22068 // (1) == false | |
22069 runString = "(1)"; | |
22070 if (false != jtt.reflect.Class_newInstance02.test(1)) { | |
22071 fail(runString); | |
22072 return; | |
22073 } | |
22074 } catch (Throwable t) { | |
22075 fail(runString, t); | |
22076 return; | |
22077 } | |
22078 pass(); | |
22079 } | |
22080 | |
22081 static void jtt_reflect_Class_newInstance03() { | |
22082 begin("jtt.reflect.Class_newInstance03"); | |
22083 String runString = null; | |
22084 try { | |
22085 // (0) == !java.lang.InstantiationException | |
22086 try { | |
22087 runString = "(0)"; | |
22088 jtt.reflect.Class_newInstance03.test(0); | |
22089 fail(runString); | |
22090 return; | |
22091 } catch (Throwable e) { | |
22092 if (e.getClass() != java.lang.InstantiationException.class) { | |
22093 fail(runString, e); | |
22094 return; | |
22095 } | |
22096 } | |
22097 // (1) == !java.lang.InstantiationException | |
22098 try { | |
22099 runString = "(1)"; | |
22100 jtt.reflect.Class_newInstance03.test(1); | |
22101 fail(runString); | |
22102 return; | |
22103 } catch (Throwable e) { | |
22104 if (e.getClass() != java.lang.InstantiationException.class) { | |
22105 fail(runString, e); | |
22106 return; | |
22107 } | |
22108 } | |
22109 // (2) == !java.lang.InstantiationException | |
22110 try { | |
22111 runString = "(2)"; | |
22112 jtt.reflect.Class_newInstance03.test(2); | |
22113 fail(runString); | |
22114 return; | |
22115 } catch (Throwable e) { | |
22116 if (e.getClass() != java.lang.InstantiationException.class) { | |
22117 fail(runString, e); | |
22118 return; | |
22119 } | |
22120 } | |
22121 // (3) == !java.lang.InstantiationException | |
22122 try { | |
22123 runString = "(3)"; | |
22124 jtt.reflect.Class_newInstance03.test(3); | |
22125 fail(runString); | |
22126 return; | |
22127 } catch (Throwable e) { | |
22128 if (e.getClass() != java.lang.InstantiationException.class) { | |
22129 fail(runString, e); | |
22130 return; | |
22131 } | |
22132 } | |
22133 // (4) == false | |
22134 runString = "(4)"; | |
22135 if (false != jtt.reflect.Class_newInstance03.test(4)) { | |
22136 fail(runString); | |
22137 return; | |
22138 } | |
22139 } catch (Throwable t) { | |
22140 fail(runString, t); | |
22141 return; | |
22142 } | |
22143 pass(); | |
22144 } | |
22145 | |
22146 static void jtt_reflect_Class_newInstance06() { | |
22147 begin("jtt.reflect.Class_newInstance06"); | |
22148 String runString = null; | |
22149 try { | |
22150 // (0) == !java.lang.InstantiationException | |
22151 try { | |
22152 runString = "(0)"; | |
22153 jtt.reflect.Class_newInstance06.test(0); | |
22154 fail(runString); | |
22155 return; | |
22156 } catch (Throwable e) { | |
22157 if (e.getClass() != java.lang.InstantiationException.class) { | |
22158 fail(runString, e); | |
22159 return; | |
22160 } | |
22161 } | |
22162 // (4) == false | |
22163 runString = "(4)"; | |
22164 if (false != jtt.reflect.Class_newInstance06.test(4)) { | |
22165 fail(runString); | |
22166 return; | |
22167 } | |
22168 } catch (Throwable t) { | |
22169 fail(runString, t); | |
22170 return; | |
22171 } | |
22172 pass(); | |
22173 } | |
22174 | |
22175 static void jtt_reflect_Class_newInstance07() { | |
22176 begin("jtt.reflect.Class_newInstance07"); | |
22177 String runString = null; | |
22178 try { | |
22179 // (0) == !java.lang.Exception | |
22180 try { | |
22181 runString = "(0)"; | |
22182 jtt.reflect.Class_newInstance07.test(0); | |
22183 fail(runString); | |
22184 return; | |
22185 } catch (Throwable e) { | |
22186 if (e.getClass() != java.lang.Exception.class) { | |
22187 fail(runString, e); | |
22188 return; | |
22189 } | |
22190 } | |
22191 // (4) == false | |
22192 runString = "(4)"; | |
22193 if (false != jtt.reflect.Class_newInstance07.test(4)) { | |
22194 fail(runString); | |
22195 return; | |
22196 } | |
22197 } catch (Throwable t) { | |
22198 fail(runString, t); | |
22199 return; | |
22200 } | |
22201 pass(); | |
22202 } | |
22203 | |
22204 static void jtt_reflect_Field_get01() { | |
22205 begin("jtt.reflect.Field_get01"); | |
22206 String runString = null; | |
22207 try { | |
22208 // (0) == true | |
22209 runString = "(0)"; | |
22210 if (true != jtt.reflect.Field_get01.test(0)) { | |
22211 fail(runString); | |
22212 return; | |
22213 } | |
22214 // (1) == true | |
22215 runString = "(1)"; | |
22216 if (true != jtt.reflect.Field_get01.test(1)) { | |
22217 fail(runString); | |
22218 return; | |
22219 } | |
22220 // (2) == true | |
22221 runString = "(2)"; | |
22222 if (true != jtt.reflect.Field_get01.test(2)) { | |
22223 fail(runString); | |
22224 return; | |
22225 } | |
22226 // (3) == true | |
22227 runString = "(3)"; | |
22228 if (true != jtt.reflect.Field_get01.test(3)) { | |
22229 fail(runString); | |
22230 return; | |
22231 } | |
22232 // (4) == true | |
22233 runString = "(4)"; | |
22234 if (true != jtt.reflect.Field_get01.test(4)) { | |
22235 fail(runString); | |
22236 return; | |
22237 } | |
22238 // (5) == true | |
22239 runString = "(5)"; | |
22240 if (true != jtt.reflect.Field_get01.test(5)) { | |
22241 fail(runString); | |
22242 return; | |
22243 } | |
22244 // (6) == true | |
22245 runString = "(6)"; | |
22246 if (true != jtt.reflect.Field_get01.test(6)) { | |
22247 fail(runString); | |
22248 return; | |
22249 } | |
22250 // (7) == true | |
22251 runString = "(7)"; | |
22252 if (true != jtt.reflect.Field_get01.test(7)) { | |
22253 fail(runString); | |
22254 return; | |
22255 } | |
22256 // (8) == false | |
22257 runString = "(8)"; | |
22258 if (false != jtt.reflect.Field_get01.test(8)) { | |
22259 fail(runString); | |
22260 return; | |
22261 } | |
22262 } catch (Throwable t) { | |
22263 fail(runString, t); | |
22264 return; | |
22265 } | |
22266 pass(); | |
22267 } | |
22268 | |
22269 static void jtt_reflect_Field_get02() { | |
22270 begin("jtt.reflect.Field_get02"); | |
22271 String runString = null; | |
22272 try { | |
22273 // (0) == true | |
22274 runString = "(0)"; | |
22275 if (true != jtt.reflect.Field_get02.test(0)) { | |
22276 fail(runString); | |
22277 return; | |
22278 } | |
22279 // (1) == true | |
22280 runString = "(1)"; | |
22281 if (true != jtt.reflect.Field_get02.test(1)) { | |
22282 fail(runString); | |
22283 return; | |
22284 } | |
22285 // (2) == true | |
22286 runString = "(2)"; | |
22287 if (true != jtt.reflect.Field_get02.test(2)) { | |
22288 fail(runString); | |
22289 return; | |
22290 } | |
22291 // (3) == true | |
22292 runString = "(3)"; | |
22293 if (true != jtt.reflect.Field_get02.test(3)) { | |
22294 fail(runString); | |
22295 return; | |
22296 } | |
22297 // (4) == true | |
22298 runString = "(4)"; | |
22299 if (true != jtt.reflect.Field_get02.test(4)) { | |
22300 fail(runString); | |
22301 return; | |
22302 } | |
22303 // (5) == true | |
22304 runString = "(5)"; | |
22305 if (true != jtt.reflect.Field_get02.test(5)) { | |
22306 fail(runString); | |
22307 return; | |
22308 } | |
22309 // (6) == true | |
22310 runString = "(6)"; | |
22311 if (true != jtt.reflect.Field_get02.test(6)) { | |
22312 fail(runString); | |
22313 return; | |
22314 } | |
22315 // (7) == true | |
22316 runString = "(7)"; | |
22317 if (true != jtt.reflect.Field_get02.test(7)) { | |
22318 fail(runString); | |
22319 return; | |
22320 } | |
22321 // (8) == false | |
22322 runString = "(8)"; | |
22323 if (false != jtt.reflect.Field_get02.test(8)) { | |
22324 fail(runString); | |
22325 return; | |
22326 } | |
22327 } catch (Throwable t) { | |
22328 fail(runString, t); | |
22329 return; | |
22330 } | |
22331 pass(); | |
22332 } | |
22333 | |
22334 static void jtt_reflect_Field_get03() { | |
22335 begin("jtt.reflect.Field_get03"); | |
22336 String runString = null; | |
22337 try { | |
22338 // (0) == true | |
22339 runString = "(0)"; | |
22340 if (true != jtt.reflect.Field_get03.test(0)) { | |
22341 fail(runString); | |
22342 return; | |
22343 } | |
22344 // (1) == true | |
22345 runString = "(1)"; | |
22346 if (true != jtt.reflect.Field_get03.test(1)) { | |
22347 fail(runString); | |
22348 return; | |
22349 } | |
22350 // (2) == true | |
22351 runString = "(2)"; | |
22352 if (true != jtt.reflect.Field_get03.test(2)) { | |
22353 fail(runString); | |
22354 return; | |
22355 } | |
22356 // (3) == true | |
22357 runString = "(3)"; | |
22358 if (true != jtt.reflect.Field_get03.test(3)) { | |
22359 fail(runString); | |
22360 return; | |
22361 } | |
22362 // (4) == true | |
22363 runString = "(4)"; | |
22364 if (true != jtt.reflect.Field_get03.test(4)) { | |
22365 fail(runString); | |
22366 return; | |
22367 } | |
22368 // (5) == true | |
22369 runString = "(5)"; | |
22370 if (true != jtt.reflect.Field_get03.test(5)) { | |
22371 fail(runString); | |
22372 return; | |
22373 } | |
22374 // (6) == true | |
22375 runString = "(6)"; | |
22376 if (true != jtt.reflect.Field_get03.test(6)) { | |
22377 fail(runString); | |
22378 return; | |
22379 } | |
22380 // (7) == true | |
22381 runString = "(7)"; | |
22382 if (true != jtt.reflect.Field_get03.test(7)) { | |
22383 fail(runString); | |
22384 return; | |
22385 } | |
22386 // (8) == false | |
22387 runString = "(8)"; | |
22388 if (false != jtt.reflect.Field_get03.test(8)) { | |
22389 fail(runString); | |
22390 return; | |
22391 } | |
22392 } catch (Throwable t) { | |
22393 fail(runString, t); | |
22394 return; | |
22395 } | |
22396 pass(); | |
22397 } | |
22398 | |
22399 static void jtt_reflect_Field_get04() { | |
22400 begin("jtt.reflect.Field_get04"); | |
22401 String runString = null; | |
22402 try { | |
22403 // (0) == true | |
22404 runString = "(0)"; | |
22405 if (true != jtt.reflect.Field_get04.test(0)) { | |
22406 fail(runString); | |
22407 return; | |
22408 } | |
22409 // (1) == true | |
22410 runString = "(1)"; | |
22411 if (true != jtt.reflect.Field_get04.test(1)) { | |
22412 fail(runString); | |
22413 return; | |
22414 } | |
22415 // (2) == true | |
22416 runString = "(2)"; | |
22417 if (true != jtt.reflect.Field_get04.test(2)) { | |
22418 fail(runString); | |
22419 return; | |
22420 } | |
22421 // (3) == true | |
22422 runString = "(3)"; | |
22423 if (true != jtt.reflect.Field_get04.test(3)) { | |
22424 fail(runString); | |
22425 return; | |
22426 } | |
22427 // (4) == true | |
22428 runString = "(4)"; | |
22429 if (true != jtt.reflect.Field_get04.test(4)) { | |
22430 fail(runString); | |
22431 return; | |
22432 } | |
22433 // (5) == true | |
22434 runString = "(5)"; | |
22435 if (true != jtt.reflect.Field_get04.test(5)) { | |
22436 fail(runString); | |
22437 return; | |
22438 } | |
22439 // (6) == true | |
22440 runString = "(6)"; | |
22441 if (true != jtt.reflect.Field_get04.test(6)) { | |
22442 fail(runString); | |
22443 return; | |
22444 } | |
22445 // (7) == true | |
22446 runString = "(7)"; | |
22447 if (true != jtt.reflect.Field_get04.test(7)) { | |
22448 fail(runString); | |
22449 return; | |
22450 } | |
22451 // (8) == false | |
22452 runString = "(8)"; | |
22453 if (false != jtt.reflect.Field_get04.test(8)) { | |
22454 fail(runString); | |
22455 return; | |
22456 } | |
22457 } catch (Throwable t) { | |
22458 fail(runString, t); | |
22459 return; | |
22460 } | |
22461 pass(); | |
22462 } | |
22463 | |
22464 static void jtt_reflect_Field_getType01() { | |
22465 begin("jtt.reflect.Field_getType01"); | |
22466 String runString = null; | |
22467 try { | |
22468 // (0) == true | |
22469 runString = "(0)"; | |
22470 if (true != jtt.reflect.Field_getType01.test(0)) { | |
22471 fail(runString); | |
22472 return; | |
22473 } | |
22474 // (1) == true | |
22475 runString = "(1)"; | |
22476 if (true != jtt.reflect.Field_getType01.test(1)) { | |
22477 fail(runString); | |
22478 return; | |
22479 } | |
22480 // (2) == true | |
22481 runString = "(2)"; | |
22482 if (true != jtt.reflect.Field_getType01.test(2)) { | |
22483 fail(runString); | |
22484 return; | |
22485 } | |
22486 // (3) == true | |
22487 runString = "(3)"; | |
22488 if (true != jtt.reflect.Field_getType01.test(3)) { | |
22489 fail(runString); | |
22490 return; | |
22491 } | |
22492 // (4) == true | |
22493 runString = "(4)"; | |
22494 if (true != jtt.reflect.Field_getType01.test(4)) { | |
22495 fail(runString); | |
22496 return; | |
22497 } | |
22498 // (5) == true | |
22499 runString = "(5)"; | |
22500 if (true != jtt.reflect.Field_getType01.test(5)) { | |
22501 fail(runString); | |
22502 return; | |
22503 } | |
22504 // (6) == true | |
22505 runString = "(6)"; | |
22506 if (true != jtt.reflect.Field_getType01.test(6)) { | |
22507 fail(runString); | |
22508 return; | |
22509 } | |
22510 // (7) == true | |
22511 runString = "(7)"; | |
22512 if (true != jtt.reflect.Field_getType01.test(7)) { | |
22513 fail(runString); | |
22514 return; | |
22515 } | |
22516 // (8) == false | |
22517 runString = "(8)"; | |
22518 if (false != jtt.reflect.Field_getType01.test(8)) { | |
22519 fail(runString); | |
22520 return; | |
22521 } | |
22522 } catch (Throwable t) { | |
22523 fail(runString, t); | |
22524 return; | |
22525 } | |
22526 pass(); | |
22527 } | |
22528 | |
22529 static void jtt_reflect_Field_set01() { | |
22530 begin("jtt.reflect.Field_set01"); | |
22531 String runString = null; | |
22532 try { | |
22533 // (0) == true | |
22534 runString = "(0)"; | |
22535 if (true != jtt.reflect.Field_set01.test(0)) { | |
22536 fail(runString); | |
22537 return; | |
22538 } | |
22539 // (1) == true | |
22540 runString = "(1)"; | |
22541 if (true != jtt.reflect.Field_set01.test(1)) { | |
22542 fail(runString); | |
22543 return; | |
22544 } | |
22545 // (2) == true | |
22546 runString = "(2)"; | |
22547 if (true != jtt.reflect.Field_set01.test(2)) { | |
22548 fail(runString); | |
22549 return; | |
22550 } | |
22551 // (3) == true | |
22552 runString = "(3)"; | |
22553 if (true != jtt.reflect.Field_set01.test(3)) { | |
22554 fail(runString); | |
22555 return; | |
22556 } | |
22557 // (4) == true | |
22558 runString = "(4)"; | |
22559 if (true != jtt.reflect.Field_set01.test(4)) { | |
22560 fail(runString); | |
22561 return; | |
22562 } | |
22563 // (5) == true | |
22564 runString = "(5)"; | |
22565 if (true != jtt.reflect.Field_set01.test(5)) { | |
22566 fail(runString); | |
22567 return; | |
22568 } | |
22569 // (6) == true | |
22570 runString = "(6)"; | |
22571 if (true != jtt.reflect.Field_set01.test(6)) { | |
22572 fail(runString); | |
22573 return; | |
22574 } | |
22575 // (7) == true | |
22576 runString = "(7)"; | |
22577 if (true != jtt.reflect.Field_set01.test(7)) { | |
22578 fail(runString); | |
22579 return; | |
22580 } | |
22581 // (8) == false | |
22582 runString = "(8)"; | |
22583 if (false != jtt.reflect.Field_set01.test(8)) { | |
22584 fail(runString); | |
22585 return; | |
22586 } | |
22587 } catch (Throwable t) { | |
22588 fail(runString, t); | |
22589 return; | |
22590 } | |
22591 pass(); | |
22592 } | |
22593 | |
22594 static void jtt_reflect_Field_set02() { | |
22595 begin("jtt.reflect.Field_set02"); | |
22596 String runString = null; | |
22597 try { | |
22598 // (0) == true | |
22599 runString = "(0)"; | |
22600 if (true != jtt.reflect.Field_set02.test(0)) { | |
22601 fail(runString); | |
22602 return; | |
22603 } | |
22604 // (1) == true | |
22605 runString = "(1)"; | |
22606 if (true != jtt.reflect.Field_set02.test(1)) { | |
22607 fail(runString); | |
22608 return; | |
22609 } | |
22610 // (2) == true | |
22611 runString = "(2)"; | |
22612 if (true != jtt.reflect.Field_set02.test(2)) { | |
22613 fail(runString); | |
22614 return; | |
22615 } | |
22616 // (3) == true | |
22617 runString = "(3)"; | |
22618 if (true != jtt.reflect.Field_set02.test(3)) { | |
22619 fail(runString); | |
22620 return; | |
22621 } | |
22622 // (4) == true | |
22623 runString = "(4)"; | |
22624 if (true != jtt.reflect.Field_set02.test(4)) { | |
22625 fail(runString); | |
22626 return; | |
22627 } | |
22628 // (5) == true | |
22629 runString = "(5)"; | |
22630 if (true != jtt.reflect.Field_set02.test(5)) { | |
22631 fail(runString); | |
22632 return; | |
22633 } | |
22634 // (6) == true | |
22635 runString = "(6)"; | |
22636 if (true != jtt.reflect.Field_set02.test(6)) { | |
22637 fail(runString); | |
22638 return; | |
22639 } | |
22640 // (7) == true | |
22641 runString = "(7)"; | |
22642 if (true != jtt.reflect.Field_set02.test(7)) { | |
22643 fail(runString); | |
22644 return; | |
22645 } | |
22646 // (8) == false | |
22647 runString = "(8)"; | |
22648 if (false != jtt.reflect.Field_set02.test(8)) { | |
22649 fail(runString); | |
22650 return; | |
22651 } | |
22652 } catch (Throwable t) { | |
22653 fail(runString, t); | |
22654 return; | |
22655 } | |
22656 pass(); | |
22657 } | |
22658 | |
22659 static void jtt_reflect_Field_set03() { | |
22660 begin("jtt.reflect.Field_set03"); | |
22661 String runString = null; | |
22662 try { | |
22663 // (0) == true | |
22664 runString = "(0)"; | |
22665 if (true != jtt.reflect.Field_set03.test(0)) { | |
22666 fail(runString); | |
22667 return; | |
22668 } | |
22669 // (1) == true | |
22670 runString = "(1)"; | |
22671 if (true != jtt.reflect.Field_set03.test(1)) { | |
22672 fail(runString); | |
22673 return; | |
22674 } | |
22675 // (2) == true | |
22676 runString = "(2)"; | |
22677 if (true != jtt.reflect.Field_set03.test(2)) { | |
22678 fail(runString); | |
22679 return; | |
22680 } | |
22681 // (3) == true | |
22682 runString = "(3)"; | |
22683 if (true != jtt.reflect.Field_set03.test(3)) { | |
22684 fail(runString); | |
22685 return; | |
22686 } | |
22687 // (4) == true | |
22688 runString = "(4)"; | |
22689 if (true != jtt.reflect.Field_set03.test(4)) { | |
22690 fail(runString); | |
22691 return; | |
22692 } | |
22693 // (5) == true | |
22694 runString = "(5)"; | |
22695 if (true != jtt.reflect.Field_set03.test(5)) { | |
22696 fail(runString); | |
22697 return; | |
22698 } | |
22699 // (6) == true | |
22700 runString = "(6)"; | |
22701 if (true != jtt.reflect.Field_set03.test(6)) { | |
22702 fail(runString); | |
22703 return; | |
22704 } | |
22705 // (7) == true | |
22706 runString = "(7)"; | |
22707 if (true != jtt.reflect.Field_set03.test(7)) { | |
22708 fail(runString); | |
22709 return; | |
22710 } | |
22711 // (8) == false | |
22712 runString = "(8)"; | |
22713 if (false != jtt.reflect.Field_set03.test(8)) { | |
22714 fail(runString); | |
22715 return; | |
22716 } | |
22717 } catch (Throwable t) { | |
22718 fail(runString, t); | |
22719 return; | |
22720 } | |
22721 pass(); | |
22722 } | |
22723 | |
22724 static void jtt_reflect_Invoke_except01() { | |
22725 begin("jtt.reflect.Invoke_except01"); | |
22726 String runString = null; | |
22727 try { | |
22728 // (0) == 0 | |
22729 runString = "(0)"; | |
22730 if (0 != jtt.reflect.Invoke_except01.test(0)) { | |
22731 fail(runString); | |
22732 return; | |
22733 } | |
22734 // (1) == 3 | |
22735 runString = "(1)"; | |
22736 if (3 != jtt.reflect.Invoke_except01.test(1)) { | |
22737 fail(runString); | |
22738 return; | |
22739 } | |
22740 // (2) == !java.lang.reflect.InvocationTargetException | |
22741 try { | |
22742 runString = "(2)"; | |
22743 jtt.reflect.Invoke_except01.test(2); | |
22744 fail(runString); | |
22745 return; | |
22746 } catch (Throwable e) { | |
22747 if (e.getClass() != java.lang.reflect.InvocationTargetException.class) { | |
22748 fail(runString, e); | |
22749 return; | |
22750 } | |
22751 } | |
22752 // (3) == !java.lang.IllegalArgumentException | |
22753 try { | |
22754 runString = "(3)"; | |
22755 jtt.reflect.Invoke_except01.test(3); | |
22756 fail(runString); | |
22757 return; | |
22758 } catch (Throwable e) { | |
22759 if (e.getClass() != java.lang.IllegalArgumentException.class) { | |
22760 fail(runString, e); | |
22761 return; | |
22762 } | |
22763 } | |
22764 // (4) == !java.lang.IllegalArgumentException | |
22765 try { | |
22766 runString = "(4)"; | |
22767 jtt.reflect.Invoke_except01.test(4); | |
22768 fail(runString); | |
22769 return; | |
22770 } catch (Throwable e) { | |
22771 if (e.getClass() != java.lang.IllegalArgumentException.class) { | |
22772 fail(runString, e); | |
22773 return; | |
22774 } | |
22775 } | |
22776 } catch (Throwable t) { | |
22777 fail(runString, t); | |
22778 return; | |
22779 } | |
22780 pass(); | |
22781 } | |
22782 | |
22783 static void jtt_reflect_Invoke_main01() { | |
22784 begin("jtt.reflect.Invoke_main01"); | |
22785 String runString = null; | |
22786 try { | |
22787 // ("test1") == "test1" | |
22788 runString = "(\"test1\")"; | |
22789 if (!"test1".equals(jtt.reflect.Invoke_main01.test("test1"))) { | |
22790 fail(runString); | |
22791 return; | |
22792 } | |
22793 // ("test2") == "test2" | |
22794 runString = "(\"test2\")"; | |
22795 if (!"test2".equals(jtt.reflect.Invoke_main01.test("test2"))) { | |
22796 fail(runString); | |
22797 return; | |
22798 } | |
22799 } catch (Throwable t) { | |
22800 fail(runString, t); | |
22801 return; | |
22802 } | |
22803 pass(); | |
22804 } | |
22805 | |
22806 static void jtt_reflect_Invoke_main02() { | |
22807 begin("jtt.reflect.Invoke_main02"); | |
22808 String runString = null; | |
22809 try { | |
22810 // ("test1") == "test1" | |
22811 runString = "(\"test1\")"; | |
22812 if (!"test1".equals(jtt.reflect.Invoke_main02.test("test1"))) { | |
22813 fail(runString); | |
22814 return; | |
22815 } | |
22816 // ("test2") == "test2" | |
22817 runString = "(\"test2\")"; | |
22818 if (!"test2".equals(jtt.reflect.Invoke_main02.test("test2"))) { | |
22819 fail(runString); | |
22820 return; | |
22821 } | |
22822 } catch (Throwable t) { | |
22823 fail(runString, t); | |
22824 return; | |
22825 } | |
22826 pass(); | |
22827 } | |
22828 | |
22829 static void jtt_reflect_Invoke_main03() { | |
22830 begin("jtt.reflect.Invoke_main03"); | |
22831 String runString = null; | |
22832 try { | |
22833 // ("test1") == "test1" | |
22834 runString = "(\"test1\")"; | |
22835 if (!"test1".equals(jtt.reflect.Invoke_main03.test("test1"))) { | |
22836 fail(runString); | |
22837 return; | |
22838 } | |
22839 // ("test2") == "test2" | |
22840 runString = "(\"test2\")"; | |
22841 if (!"test2".equals(jtt.reflect.Invoke_main03.test("test2"))) { | |
22842 fail(runString); | |
22843 return; | |
22844 } | |
22845 } catch (Throwable t) { | |
22846 fail(runString, t); | |
22847 return; | |
22848 } | |
22849 pass(); | |
22850 } | |
22851 | |
22852 static void jtt_reflect_Invoke_virtual01() { | |
22853 begin("jtt.reflect.Invoke_virtual01"); | |
22854 String runString = null; | |
22855 try { | |
22856 // (1) == 55 | |
22857 runString = "(1)"; | |
22858 if (55 != jtt.reflect.Invoke_virtual01.test(1)) { | |
22859 fail(runString); | |
22860 return; | |
22861 } | |
22862 } catch (Throwable t) { | |
22863 fail(runString, t); | |
22864 return; | |
22865 } | |
22866 pass(); | |
22867 } | |
22868 | |
22869 static void jtt_reflect_Method_getParameterTypes01() { | |
22870 begin("jtt.reflect.Method_getParameterTypes01"); | |
22871 String runString = null; | |
22872 try { | |
22873 // (0) == 0 | |
22874 runString = "(0)"; | |
22875 if (0 != jtt.reflect.Method_getParameterTypes01.test(0)) { | |
22876 fail(runString); | |
22877 return; | |
22878 } | |
22879 // (1) == 1 | |
22880 runString = "(1)"; | |
22881 if (1 != jtt.reflect.Method_getParameterTypes01.test(1)) { | |
22882 fail(runString); | |
22883 return; | |
22884 } | |
22885 // (2) == 2 | |
22886 runString = "(2)"; | |
22887 if (2 != jtt.reflect.Method_getParameterTypes01.test(2)) { | |
22888 fail(runString); | |
22889 return; | |
22890 } | |
22891 // (3) == -1 | |
22892 runString = "(3)"; | |
22893 if (-1 != jtt.reflect.Method_getParameterTypes01.test(3)) { | |
22894 fail(runString); | |
22895 return; | |
22896 } | |
22897 } catch (Throwable t) { | |
22898 fail(runString, t); | |
22899 return; | |
22900 } | |
22901 pass(); | |
22902 } | |
22903 | |
22904 static void jtt_reflect_Method_getReturnType01() { | |
22905 begin("jtt.reflect.Method_getReturnType01"); | |
22906 String runString = null; | |
22907 try { | |
22908 // (0) == "int" | |
22909 runString = "(0)"; | |
22910 if (!"int".equals(jtt.reflect.Method_getReturnType01.test(0))) { | |
22911 fail(runString); | |
22912 return; | |
22913 } | |
22914 // (1) == "java.lang.String" | |
22915 runString = "(1)"; | |
22916 if (!"java.lang.String".equals(jtt.reflect.Method_getReturnType01 | |
22917 .test(1))) { | |
22918 fail(runString); | |
22919 return; | |
22920 } | |
22921 // (2) == "void" | |
22922 runString = "(2)"; | |
22923 if (!"void".equals(jtt.reflect.Method_getReturnType01.test(2))) { | |
22924 fail(runString); | |
22925 return; | |
22926 } | |
22927 // (3) == null | |
22928 runString = "(3)"; | |
22929 if (null != jtt.reflect.Method_getReturnType01.test(3)) { | |
22930 fail(runString); | |
22931 return; | |
22932 } | |
22933 } catch (Throwable t) { | |
22934 fail(runString, t); | |
22935 return; | |
22936 } | |
22937 pass(); | |
22938 } | |
22939 | |
22940 static void jtt_reflect_Reflection_getCallerClass01() { | |
22941 begin("jtt.reflect.Reflection_getCallerClass01"); | |
22942 String runString = null; | |
22943 try { | |
22944 // (0) == "sun.reflect.Reflection" | |
22945 runString = "(0)"; | |
22946 if (!"sun.reflect.Reflection" | |
22947 .equals(jtt.reflect.Reflection_getCallerClass01.test(0))) { | |
22948 fail(runString); | |
22949 return; | |
22950 } | |
22951 // (1) == "jtt.reflect.Reflection_getCallerClass01$Caller1" | |
22952 runString = "(1)"; | |
22953 if (!"jtt.reflect.Reflection_getCallerClass01$Caller1" | |
22954 .equals(jtt.reflect.Reflection_getCallerClass01.test(1))) { | |
22955 fail(runString); | |
22956 return; | |
22957 } | |
22958 // (2) == "jtt.reflect.Reflection_getCallerClass01$Caller2" | |
22959 runString = "(2)"; | |
22960 if (!"jtt.reflect.Reflection_getCallerClass01$Caller2" | |
22961 .equals(jtt.reflect.Reflection_getCallerClass01.test(2))) { | |
22962 fail(runString); | |
22963 return; | |
22964 } | |
22965 } catch (Throwable t) { | |
22966 fail(runString, t); | |
22967 return; | |
22968 } | |
22969 pass(); | |
22970 } | |
22971 | |
22972 static void jtt_threads_Monitor_contended01() { | |
22973 begin("jtt.threads.Monitor_contended01"); | |
22974 String runString = null; | |
22975 try { | |
22976 // (0) == true | |
22977 runString = "(0)"; | |
22978 if (true != jtt.threads.Monitor_contended01.test(0)) { | |
22979 fail(runString); | |
22980 return; | |
22981 } | |
22982 } catch (Throwable t) { | |
22983 fail(runString, t); | |
22984 return; | |
22985 } | |
22986 pass(); | |
22987 } | |
22988 | |
22989 static void jtt_threads_Monitor_notowner01() { | |
22990 begin("jtt.threads.Monitor_notowner01"); | |
22991 String runString = null; | |
22992 try { | |
22993 // (0) == true | |
22994 runString = "(0)"; | |
22995 if (true != jtt.threads.Monitor_notowner01.test(0)) { | |
22996 fail(runString); | |
22997 return; | |
22998 } | |
22999 } catch (Throwable t) { | |
23000 fail(runString, t); | |
23001 return; | |
23002 } | |
23003 pass(); | |
23004 } | |
23005 | |
23006 static void jtt_threads_Monitorenter01() { | |
23007 begin("jtt.threads.Monitorenter01"); | |
23008 String runString = null; | |
23009 try { | |
23010 // (0) == true | |
23011 runString = "(0)"; | |
23012 if (true != jtt.threads.Monitorenter01.test(0)) { | |
23013 fail(runString); | |
23014 return; | |
23015 } | |
23016 } catch (Throwable t) { | |
23017 fail(runString, t); | |
23018 return; | |
23019 } | |
23020 pass(); | |
23021 } | |
23022 | |
23023 static void jtt_threads_Monitorenter02() { | |
23024 begin("jtt.threads.Monitorenter02"); | |
23025 String runString = null; | |
23026 try { | |
23027 // (0) == true | |
23028 runString = "(0)"; | |
23029 if (true != jtt.threads.Monitorenter02.test(0)) { | |
23030 fail(runString); | |
23031 return; | |
23032 } | |
23033 } catch (Throwable t) { | |
23034 fail(runString, t); | |
23035 return; | |
23036 } | |
23037 pass(); | |
23038 } | |
23039 | |
23040 static void jtt_threads_Object_wait01() { | |
23041 begin("jtt.threads.Object_wait01"); | |
23042 String runString = null; | |
23043 try { | |
23044 // (0) == true | |
23045 runString = "(0)"; | |
23046 if (true != jtt.threads.Object_wait01.test(0)) { | |
23047 fail(runString); | |
23048 return; | |
23049 } | |
23050 // (1) == true | |
23051 runString = "(1)"; | |
23052 if (true != jtt.threads.Object_wait01.test(1)) { | |
23053 fail(runString); | |
23054 return; | |
23055 } | |
23056 // (3) == true | |
23057 runString = "(3)"; | |
23058 if (true != jtt.threads.Object_wait01.test(3)) { | |
23059 fail(runString); | |
23060 return; | |
23061 } | |
23062 // (15) == true | |
23063 runString = "(15)"; | |
23064 if (true != jtt.threads.Object_wait01.test(15)) { | |
23065 fail(runString); | |
23066 return; | |
23067 } | |
23068 } catch (Throwable t) { | |
23069 fail(runString, t); | |
23070 return; | |
23071 } | |
23072 pass(); | |
23073 } | |
23074 | |
23075 static void jtt_threads_Object_wait02() { | |
23076 begin("jtt.threads.Object_wait02"); | |
23077 String runString = null; | |
23078 try { | |
23079 // (0) == true | |
23080 runString = "(0)"; | |
23081 if (true != jtt.threads.Object_wait02.test(0)) { | |
23082 fail(runString); | |
23083 return; | |
23084 } | |
23085 // (1) == true | |
23086 runString = "(1)"; | |
23087 if (true != jtt.threads.Object_wait02.test(1)) { | |
23088 fail(runString); | |
23089 return; | |
23090 } | |
23091 // (2) == true | |
23092 runString = "(2)"; | |
23093 if (true != jtt.threads.Object_wait02.test(2)) { | |
23094 fail(runString); | |
23095 return; | |
23096 } | |
23097 } catch (Throwable t) { | |
23098 fail(runString, t); | |
23099 return; | |
23100 } | |
23101 pass(); | |
23102 } | |
23103 | |
23104 static void jtt_threads_Object_wait03() { | |
23105 begin("jtt.threads.Object_wait03"); | |
23106 String runString = null; | |
23107 try { | |
23108 // (0) == true | |
23109 runString = "(0)"; | |
23110 if (true != jtt.threads.Object_wait03.test(0)) { | |
23111 fail(runString); | |
23112 return; | |
23113 } | |
23114 // (1) == true | |
23115 runString = "(1)"; | |
23116 if (true != jtt.threads.Object_wait03.test(1)) { | |
23117 fail(runString); | |
23118 return; | |
23119 } | |
23120 // (2) == true | |
23121 runString = "(2)"; | |
23122 if (true != jtt.threads.Object_wait03.test(2)) { | |
23123 fail(runString); | |
23124 return; | |
23125 } | |
23126 } catch (Throwable t) { | |
23127 fail(runString, t); | |
23128 return; | |
23129 } | |
23130 pass(); | |
23131 } | |
23132 | |
23133 static void jtt_threads_Object_wait04() { | |
23134 begin("jtt.threads.Object_wait04"); | |
23135 String runString = null; | |
23136 try { | |
23137 // (0) == true | |
23138 runString = "(0)"; | |
23139 if (true != jtt.threads.Object_wait04.test(0)) { | |
23140 fail(runString); | |
23141 return; | |
23142 } | |
23143 // (1) == true | |
23144 runString = "(1)"; | |
23145 if (true != jtt.threads.Object_wait04.test(1)) { | |
23146 fail(runString); | |
23147 return; | |
23148 } | |
23149 // (2) == true | |
23150 runString = "(2)"; | |
23151 if (true != jtt.threads.Object_wait04.test(2)) { | |
23152 fail(runString); | |
23153 return; | |
23154 } | |
23155 // (3) == true | |
23156 runString = "(3)"; | |
23157 if (true != jtt.threads.Object_wait04.test(3)) { | |
23158 fail(runString); | |
23159 return; | |
23160 } | |
23161 // (4) == true | |
23162 runString = "(4)"; | |
23163 if (true != jtt.threads.Object_wait04.test(4)) { | |
23164 fail(runString); | |
23165 return; | |
23166 } | |
23167 // (5) == true | |
23168 runString = "(5)"; | |
23169 if (true != jtt.threads.Object_wait04.test(5)) { | |
23170 fail(runString); | |
23171 return; | |
23172 } | |
23173 } catch (Throwable t) { | |
23174 fail(runString, t); | |
23175 return; | |
23176 } | |
23177 pass(); | |
23178 } | |
23179 | |
23180 static void jtt_threads_ThreadLocal01() { | |
23181 begin("jtt.threads.ThreadLocal01"); | |
23182 String runString = null; | |
23183 try { | |
23184 // (0) == 5 | |
23185 runString = "(0)"; | |
23186 if (5 != jtt.threads.ThreadLocal01.test(0)) { | |
23187 fail(runString); | |
23188 return; | |
23189 } | |
23190 // (1) == 6 | |
23191 runString = "(1)"; | |
23192 if (6 != jtt.threads.ThreadLocal01.test(1)) { | |
23193 fail(runString); | |
23194 return; | |
23195 } | |
23196 // (2) == 7 | |
23197 runString = "(2)"; | |
23198 if (7 != jtt.threads.ThreadLocal01.test(2)) { | |
23199 fail(runString); | |
23200 return; | |
23201 } | |
23202 } catch (Throwable t) { | |
23203 fail(runString, t); | |
23204 return; | |
23205 } | |
23206 pass(); | |
23207 } | |
23208 | |
23209 static void jtt_threads_ThreadLocal02() { | |
23210 begin("jtt.threads.ThreadLocal02"); | |
23211 String runString = null; | |
23212 try { | |
23213 // (0) == 5 | |
23214 runString = "(0)"; | |
23215 if (5 != jtt.threads.ThreadLocal02.test(0)) { | |
23216 fail(runString); | |
23217 return; | |
23218 } | |
23219 // (1) == 6 | |
23220 runString = "(1)"; | |
23221 if (6 != jtt.threads.ThreadLocal02.test(1)) { | |
23222 fail(runString); | |
23223 return; | |
23224 } | |
23225 // (2) == 7 | |
23226 runString = "(2)"; | |
23227 if (7 != jtt.threads.ThreadLocal02.test(2)) { | |
23228 fail(runString); | |
23229 return; | |
23230 } | |
23231 } catch (Throwable t) { | |
23232 fail(runString, t); | |
23233 return; | |
23234 } | |
23235 pass(); | |
23236 } | |
23237 | |
23238 static void jtt_threads_ThreadLocal03() { | |
23239 begin("jtt.threads.ThreadLocal03"); | |
23240 String runString = null; | |
23241 try { | |
23242 // (0) == 0 | |
23243 runString = "(0)"; | |
23244 if (0 != jtt.threads.ThreadLocal03.test(0)) { | |
23245 fail(runString); | |
23246 return; | |
23247 } | |
23248 // (1) == 15 | |
23249 runString = "(1)"; | |
23250 if (15 != jtt.threads.ThreadLocal03.test(1)) { | |
23251 fail(runString); | |
23252 return; | |
23253 } | |
23254 // (2) == 31 | |
23255 runString = "(2)"; | |
23256 if (31 != jtt.threads.ThreadLocal03.test(2)) { | |
23257 fail(runString); | |
23258 return; | |
23259 } | |
23260 // (3) == 48 | |
23261 runString = "(3)"; | |
23262 if (48 != jtt.threads.ThreadLocal03.test(3)) { | |
23263 fail(runString); | |
23264 return; | |
23265 } | |
23266 } catch (Throwable t) { | |
23267 fail(runString, t); | |
23268 return; | |
23269 } | |
23270 pass(); | |
23271 } | |
23272 | |
23273 static void jtt_threads_Thread_currentThread01() { | |
23274 begin("jtt.threads.Thread_currentThread01"); | |
23275 String runString = null; | |
23276 try { | |
23277 // (0) == true | |
23278 runString = "(0)"; | |
23279 if (true != jtt.threads.Thread_currentThread01.test(0)) { | |
23280 fail(runString); | |
23281 return; | |
23282 } | |
23283 } catch (Throwable t) { | |
23284 fail(runString, t); | |
23285 return; | |
23286 } | |
23287 pass(); | |
23288 } | |
23289 | |
23290 static void jtt_threads_Thread_getState01() { | |
23291 begin("jtt.threads.Thread_getState01"); | |
23292 String runString = null; | |
23293 try { | |
23294 // (0) == true | |
23295 runString = "(0)"; | |
23296 if (true != jtt.threads.Thread_getState01.test(0)) { | |
23297 fail(runString); | |
23298 return; | |
23299 } | |
23300 } catch (Throwable t) { | |
23301 fail(runString, t); | |
23302 return; | |
23303 } | |
23304 pass(); | |
23305 } | |
23306 | |
23307 static void jtt_threads_Thread_getState02() { | |
23308 begin("jtt.threads.Thread_getState02"); | |
23309 String runString = null; | |
23310 try { | |
23311 // (0) == true | |
23312 runString = "(0)"; | |
23313 if (true != jtt.threads.Thread_getState02.test(0)) { | |
23314 fail(runString); | |
23315 return; | |
23316 } | |
23317 } catch (Throwable t) { | |
23318 fail(runString, t); | |
23319 return; | |
23320 } | |
23321 pass(); | |
23322 } | |
23323 | |
23324 static void jtt_threads_Thread_holdsLock01() { | |
23325 begin("jtt.threads.Thread_holdsLock01"); | |
23326 String runString = null; | |
23327 try { | |
23328 // (0) == true | |
23329 runString = "(0)"; | |
23330 if (true != jtt.threads.Thread_holdsLock01.test(0)) { | |
23331 fail(runString); | |
23332 return; | |
23333 } | |
23334 // (1) == false | |
23335 runString = "(1)"; | |
23336 if (false != jtt.threads.Thread_holdsLock01.test(1)) { | |
23337 fail(runString); | |
23338 return; | |
23339 } | |
23340 // (2) == !java.lang.NullPointerException | |
23341 try { | |
23342 runString = "(2)"; | |
23343 jtt.threads.Thread_holdsLock01.test(2); | |
23344 fail(runString); | |
23345 return; | |
23346 } catch (Throwable e) { | |
23347 if (e.getClass() != java.lang.NullPointerException.class) { | |
23348 fail(runString, e); | |
23349 return; | |
23350 } | |
23351 } | |
23352 // (3) == false | |
23353 runString = "(3)"; | |
23354 if (false != jtt.threads.Thread_holdsLock01.test(3)) { | |
23355 fail(runString); | |
23356 return; | |
23357 } | |
23358 } catch (Throwable t) { | |
23359 fail(runString, t); | |
23360 return; | |
23361 } | |
23362 pass(); | |
23363 } | |
23364 | |
23365 static void jtt_threads_Thread_isAlive01() { | |
23366 begin("jtt.threads.Thread_isAlive01"); | |
23367 String runString = null; | |
23368 try { | |
23369 // (0) == true | |
23370 runString = "(0)"; | |
23371 if (true != jtt.threads.Thread_isAlive01.test(0)) { | |
23372 fail(runString); | |
23373 return; | |
23374 } | |
23375 } catch (Throwable t) { | |
23376 fail(runString, t); | |
23377 return; | |
23378 } | |
23379 pass(); | |
23380 } | |
23381 | |
23382 static void jtt_threads_Thread_isInterrupted01() { | |
23383 begin("jtt.threads.Thread_isInterrupted01"); | |
23384 String runString = null; | |
23385 try { | |
23386 // (0) == false | |
23387 runString = "(0)"; | |
23388 if (false != jtt.threads.Thread_isInterrupted01.test(0)) { | |
23389 fail(runString); | |
23390 return; | |
23391 } | |
23392 } catch (Throwable t) { | |
23393 fail(runString, t); | |
23394 return; | |
23395 } | |
23396 pass(); | |
23397 } | |
23398 | |
23399 static void jtt_threads_Thread_isInterrupted02() { | |
23400 begin("jtt.threads.Thread_isInterrupted02"); | |
23401 String runString = null; | |
23402 try { | |
23403 // (0,0) == true | |
23404 runString = "(0,0)"; | |
23405 if (true != jtt.threads.Thread_isInterrupted02.test(0, 0)) { | |
23406 fail(runString); | |
23407 return; | |
23408 } | |
23409 // (1,500) == true | |
23410 runString = "(1,500)"; | |
23411 if (true != jtt.threads.Thread_isInterrupted02.test(1, 500)) { | |
23412 fail(runString); | |
23413 return; | |
23414 } | |
23415 } catch (Throwable t) { | |
23416 fail(runString, t); | |
23417 return; | |
23418 } | |
23419 pass(); | |
23420 } | |
23421 | |
23422 static void jtt_threads_Thread_isInterrupted03() { | |
23423 begin("jtt.threads.Thread_isInterrupted03"); | |
23424 String runString = null; | |
23425 try { | |
23426 // (0) == true | |
23427 runString = "(0)"; | |
23428 if (true != jtt.threads.Thread_isInterrupted03.test(0)) { | |
23429 fail(runString); | |
23430 return; | |
23431 } | |
23432 } catch (Throwable t) { | |
23433 fail(runString, t); | |
23434 return; | |
23435 } | |
23436 pass(); | |
23437 } | |
23438 | |
23439 static void jtt_threads_Thread_isInterrupted04() { | |
23440 begin("jtt.threads.Thread_isInterrupted04"); | |
23441 String runString = null; | |
23442 try { | |
23443 // (0) == true | |
23444 runString = "(0)"; | |
23445 if (true != jtt.threads.Thread_isInterrupted04.test(0)) { | |
23446 fail(runString); | |
23447 return; | |
23448 } | |
23449 } catch (Throwable t) { | |
23450 fail(runString, t); | |
23451 return; | |
23452 } | |
23453 pass(); | |
23454 } | |
23455 | |
23456 static void jtt_threads_Thread_isInterrupted05() { | |
23457 begin("jtt.threads.Thread_isInterrupted05"); | |
23458 String runString = null; | |
23459 try { | |
23460 // (0) == true | |
23461 runString = "(0)"; | |
23462 if (true != jtt.threads.Thread_isInterrupted05.test(0)) { | |
23463 fail(runString); | |
23464 return; | |
23465 } | |
23466 } catch (Throwable t) { | |
23467 fail(runString, t); | |
23468 return; | |
23469 } | |
23470 pass(); | |
23471 } | |
23472 | |
23473 static void jtt_threads_Thread_join01() { | |
23474 begin("jtt.threads.Thread_join01"); | |
23475 String runString = null; | |
23476 try { | |
23477 // (0) == false | |
23478 runString = "(0)"; | |
23479 if (false != jtt.threads.Thread_join01.test(0)) { | |
23480 fail(runString); | |
23481 return; | |
23482 } | |
23483 } catch (Throwable t) { | |
23484 fail(runString, t); | |
23485 return; | |
23486 } | |
23487 pass(); | |
23488 } | |
23489 | |
23490 static void jtt_threads_Thread_join02() { | |
23491 begin("jtt.threads.Thread_join02"); | |
23492 String runString = null; | |
23493 try { | |
23494 // (0) == false | |
23495 runString = "(0)"; | |
23496 if (false != jtt.threads.Thread_join02.test(0)) { | |
23497 fail(runString); | |
23498 return; | |
23499 } | |
23500 } catch (Throwable t) { | |
23501 fail(runString, t); | |
23502 return; | |
23503 } | |
23504 pass(); | |
23505 } | |
23506 | |
23507 static void jtt_threads_Thread_join03() { | |
23508 begin("jtt.threads.Thread_join03"); | |
23509 String runString = null; | |
23510 try { | |
23511 // (0) == false | |
23512 runString = "(0)"; | |
23513 if (false != jtt.threads.Thread_join03.test(0)) { | |
23514 fail(runString); | |
23515 return; | |
23516 } | |
23517 } catch (Throwable t) { | |
23518 fail(runString, t); | |
23519 return; | |
23520 } | |
23521 pass(); | |
23522 } | |
23523 | |
23524 static void jtt_threads_Thread_new01() { | |
23525 begin("jtt.threads.Thread_new01"); | |
23526 String runString = null; | |
23527 try { | |
23528 // (0) == true | |
23529 runString = "(0)"; | |
23530 if (true != jtt.threads.Thread_new01.test(0)) { | |
23531 fail(runString); | |
23532 return; | |
23533 } | |
23534 // (1) == true | |
23535 runString = "(1)"; | |
23536 if (true != jtt.threads.Thread_new01.test(1)) { | |
23537 fail(runString); | |
23538 return; | |
23539 } | |
23540 // (2) == true | |
23541 runString = "(2)"; | |
23542 if (true != jtt.threads.Thread_new01.test(2)) { | |
23543 fail(runString); | |
23544 return; | |
23545 } | |
23546 // (3) == true | |
23547 runString = "(3)"; | |
23548 if (true != jtt.threads.Thread_new01.test(3)) { | |
23549 fail(runString); | |
23550 return; | |
23551 } | |
23552 // (4) == false | |
23553 runString = "(4)"; | |
23554 if (false != jtt.threads.Thread_new01.test(4)) { | |
23555 fail(runString); | |
23556 return; | |
23557 } | |
23558 } catch (Throwable t) { | |
23559 fail(runString, t); | |
23560 return; | |
23561 } | |
23562 pass(); | |
23563 } | |
23564 | |
23565 static void jtt_threads_Thread_new02() { | |
23566 begin("jtt.threads.Thread_new02"); | |
23567 String runString = null; | |
23568 try { | |
23569 // (0) == true | |
23570 runString = "(0)"; | |
23571 if (true != jtt.threads.Thread_new02.test(0)) { | |
23572 fail(runString); | |
23573 return; | |
23574 } | |
23575 // (1) == true | |
23576 runString = "(1)"; | |
23577 if (true != jtt.threads.Thread_new02.test(1)) { | |
23578 fail(runString); | |
23579 return; | |
23580 } | |
23581 // (2) == true | |
23582 runString = "(2)"; | |
23583 if (true != jtt.threads.Thread_new02.test(2)) { | |
23584 fail(runString); | |
23585 return; | |
23586 } | |
23587 // (3) == true | |
23588 runString = "(3)"; | |
23589 if (true != jtt.threads.Thread_new02.test(3)) { | |
23590 fail(runString); | |
23591 return; | |
23592 } | |
23593 // (4) == false | |
23594 runString = "(4)"; | |
23595 if (false != jtt.threads.Thread_new02.test(4)) { | |
23596 fail(runString); | |
23597 return; | |
23598 } | |
23599 } catch (Throwable t) { | |
23600 fail(runString, t); | |
23601 return; | |
23602 } | |
23603 pass(); | |
23604 } | |
23605 | |
23606 static void jtt_threads_Thread_setPriority01() { | |
23607 begin("jtt.threads.Thread_setPriority01"); | |
23608 String runString = null; | |
23609 try { | |
23610 // (0) == !java.lang.IllegalArgumentException | |
23611 try { | |
23612 runString = "(0)"; | |
23613 jtt.threads.Thread_setPriority01.test(0); | |
23614 fail(runString); | |
23615 return; | |
23616 } catch (Throwable e) { | |
23617 if (e.getClass() != java.lang.IllegalArgumentException.class) { | |
23618 fail(runString, e); | |
23619 return; | |
23620 } | |
23621 } | |
23622 // (1) == true | |
23623 runString = "(1)"; | |
23624 if (true != jtt.threads.Thread_setPriority01.test(1)) { | |
23625 fail(runString); | |
23626 return; | |
23627 } | |
23628 // (5) == true | |
23629 runString = "(5)"; | |
23630 if (true != jtt.threads.Thread_setPriority01.test(5)) { | |
23631 fail(runString); | |
23632 return; | |
23633 } | |
23634 // (10) == true | |
23635 runString = "(10)"; | |
23636 if (true != jtt.threads.Thread_setPriority01.test(10)) { | |
23637 fail(runString); | |
23638 return; | |
23639 } | |
23640 // (11) == !java.lang.IllegalArgumentException | |
23641 try { | |
23642 runString = "(11)"; | |
23643 jtt.threads.Thread_setPriority01.test(11); | |
23644 fail(runString); | |
23645 return; | |
23646 } catch (Throwable e) { | |
23647 if (e.getClass() != java.lang.IllegalArgumentException.class) { | |
23648 fail(runString, e); | |
23649 return; | |
23650 } | |
23651 } | |
23652 } catch (Throwable t) { | |
23653 fail(runString, t); | |
23654 return; | |
23655 } | |
23656 pass(); | |
23657 } | |
23658 | |
23659 static void jtt_threads_Thread_sleep01() { | |
23660 begin("jtt.threads.Thread_sleep01"); | |
23661 String runString = null; | |
23662 try { | |
23663 // (10) == true | |
23664 runString = "(10)"; | |
23665 if (true != jtt.threads.Thread_sleep01.test(10)) { | |
23666 fail(runString); | |
23667 return; | |
23668 } | |
23669 // (20) == true | |
23670 runString = "(20)"; | |
23671 if (true != jtt.threads.Thread_sleep01.test(20)) { | |
23672 fail(runString); | |
23673 return; | |
23674 } | |
23675 // (100) == true | |
23676 runString = "(100)"; | |
23677 if (true != jtt.threads.Thread_sleep01.test(100)) { | |
23678 fail(runString); | |
23679 return; | |
23680 } | |
23681 } catch (Throwable t) { | |
23682 fail(runString, t); | |
23683 return; | |
23684 } | |
23685 pass(); | |
23686 } | |
23687 | |
23688 static void jtt_threads_Thread_start01() { | |
23689 begin("jtt.threads.Thread_start01"); | |
23690 String runString = null; | |
23691 try { | |
23692 // (0) == true | |
23693 runString = "(0)"; | |
23694 if (true != jtt.threads.Thread_start01.test(0)) { | |
23695 fail(runString); | |
23696 return; | |
23697 } | |
23698 } catch (Throwable t) { | |
23699 fail(runString, t); | |
23700 return; | |
23701 } | |
23702 pass(); | |
23703 } | |
23704 | |
23705 static void jtt_threads_Thread_yield01() { | |
23706 begin("jtt.threads.Thread_yield01"); | |
23707 String runString = null; | |
23708 try { | |
23709 // (0) == true | |
23710 runString = "(0)"; | |
23711 if (true != jtt.threads.Thread_yield01.test(0)) { | |
23712 fail(runString); | |
23713 return; | |
23714 } | |
23715 } catch (Throwable t) { | |
23716 fail(runString, t); | |
23717 return; | |
23718 } | |
23719 pass(); | |
23720 } | |
23721 | |
23722 static void jtt_jdk_Class_getName() { | |
23723 begin("jtt.jdk.Class_getName"); | |
23724 String runString = null; | |
23725 try { | |
23726 // (0) == "java.lang.String" | |
23727 runString = "(0)"; | |
23728 if (!"java.lang.String".equals(jtt.jdk.Class_getName.test(0))) { | |
23729 fail(runString); | |
23730 return; | |
23731 } | |
23732 } catch (Throwable t) { | |
23733 fail(runString, t); | |
23734 return; | |
23735 } | |
23736 pass(); | |
23737 } | |
23738 | |
23739 static void jtt_jdk_EnumMap01() { | |
23740 begin("jtt.jdk.EnumMap01"); | |
23741 String runString = null; | |
23742 try { | |
23743 // (0) == "A" | |
23744 runString = "(0)"; | |
23745 if (!"A".equals(jtt.jdk.EnumMap01.test(0))) { | |
23746 fail(runString); | |
23747 return; | |
23748 } | |
23749 } catch (Throwable t) { | |
23750 fail(runString, t); | |
23751 return; | |
23752 } | |
23753 pass(); | |
23754 } | |
23755 | |
23756 static void jtt_jdk_EnumMap02() { | |
23757 begin("jtt.jdk.EnumMap02"); | |
23758 String runString = null; | |
23759 try { | |
23760 // (0) == "A" | |
23761 runString = "(0)"; | |
23762 if (!"A".equals(jtt.jdk.EnumMap02.test(0))) { | |
23763 fail(runString); | |
23764 return; | |
23765 } | |
23766 } catch (Throwable t) { | |
23767 fail(runString, t); | |
23768 return; | |
23769 } | |
23770 pass(); | |
23771 } | |
23772 | |
23773 static void jtt_jdk_System_currentTimeMillis01() { | |
23774 begin("jtt.jdk.System_currentTimeMillis01"); | |
23775 String runString = null; | |
23776 try { | |
23777 // (0) == 1 | |
23778 runString = "(0)"; | |
23779 if (1 != jtt.jdk.System_currentTimeMillis01.test(0)) { | |
23780 fail(runString); | |
23781 return; | |
23782 } | |
23783 } catch (Throwable t) { | |
23784 fail(runString, t); | |
23785 return; | |
23786 } | |
23787 pass(); | |
23788 } | |
23789 | |
23790 static void jtt_jdk_System_currentTimeMillis02() { | |
23791 begin("jtt.jdk.System_currentTimeMillis02"); | |
23792 String runString = null; | |
23793 try { | |
23794 // (0) == true | |
23795 runString = "(0)"; | |
23796 if (true != jtt.jdk.System_currentTimeMillis02.test(0)) { | |
23797 fail(runString); | |
23798 return; | |
23799 } | |
23800 } catch (Throwable t) { | |
23801 fail(runString, t); | |
23802 return; | |
23803 } | |
23804 pass(); | |
23805 } | |
23806 | |
23807 static void jtt_jdk_System_nanoTime01() { | |
23808 begin("jtt.jdk.System_nanoTime01"); | |
23809 String runString = null; | |
23810 try { | |
23811 // (0) == 1 | |
23812 runString = "(0)"; | |
23813 if (1 != jtt.jdk.System_nanoTime01.test(0)) { | |
23814 fail(runString); | |
23815 return; | |
23816 } | |
23817 } catch (Throwable t) { | |
23818 fail(runString, t); | |
23819 return; | |
23820 } | |
23821 pass(); | |
23822 } | |
23823 | |
23824 static void jtt_jdk_System_nanoTime02() { | |
23825 begin("jtt.jdk.System_nanoTime02"); | |
23826 String runString = null; | |
23827 try { | |
23828 // (0) == true | |
23829 runString = "(0)"; | |
23830 if (true != jtt.jdk.System_nanoTime02.test(0)) { | |
23831 fail(runString); | |
23832 return; | |
23833 } | |
23834 } catch (Throwable t) { | |
23835 fail(runString, t); | |
23836 return; | |
23837 } | |
23838 pass(); | |
23839 } | |
23840 | |
23841 static void jtt_jdk_UnsafeAccess01() { | |
23842 begin("jtt.jdk.UnsafeAccess01"); | |
23843 String runString = null; | |
23844 try { | |
23845 // (0) == 42 | |
23846 runString = "(0)"; | |
23847 if (42 != jtt.jdk.UnsafeAccess01.test(0)) { | |
23848 fail(runString); | |
23849 return; | |
23850 } | |
23851 } catch (Throwable t) { | |
23852 fail(runString, t); | |
23853 return; | |
23854 } | |
23855 pass(); | |
23856 } | |
23857 // END GENERATED TEST RUNS | |
23858 // Checkstyle: resume | |
23859 | |
23860 } |