Mercurial > hg > graal-jvmci-8

comparison c1x4hotspotsrc/HotSpotTest/src/jttTests.java @ 1423:760213a60e8b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
* 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 }