Mercurial > hg > graal-compiler

comparison c1x4hotspotsrc/HotSpotTest/src/JavaTester.java @ 1433:efba53f86c4f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
various fixes and enhancements * correct refmap->oopmap conversion (register numbering, stack slot numbering) * fixes for inlining (correct scoping in exception handler lookup, NPE in scope conversion) * support for "jump to runtime stub" (patching code needs to be aware of jmp instruction) * provide more information about methods (to allow inlining: has_balanced_monitors, etc.) * fixes to signature type lookup * isSubTypeOf: correct handling of array classes * RiType: componentType/arrayOf * prologue: inline cache check, icmiss stub * klass state check (resolved but not initialized) in newinstance * card table write barriers * c1x classes are optional (to allow running c1 without them) * correct for stored frame pointer in calling conventions (methods with arguments on stack) * getType(Class<?>) for some basic types, used for optimizations and folding * RiMethod/RiType: throw exception instead of silent failure on unsupported operations * RiType: resolved/unresolved array type support * refactoring: new on-demand template generation mechanism * optimizations: template specialization for no_null_check, given length, etc.
author Lukas Stadler <lukas.stadler@oracle.com>
date Thu, 16 Sep 2010 19:42:20 -0700
parents
children 72cfb36c6bb2
comparison
equal deleted inserted replaced
1432:b61a43cd1255 1433:efba53f86c4f
1
2 import com.sun.hotspot.c1x.logging.Logger;
3
4 public class JavaTester {
5
6 public static void main(String[] args) {
7 runTests(0, 1000);
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 JavaTester.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 case 588:
1819 jtt_micro_ReferenceMap01();
1820 break;
1821 }
1822 return true;
1823 }
1824
1825 static void jtt_bytecode_BC_aaload() {
1826 begin("jtt.bytecode.BC_aaload");
1827 String runString = null;
1828 try {
1829 // (0) == null
1830 runString = "(0)";
1831 if (null != jtt.bytecode.BC_aaload.test(0)) {
1832 fail(runString);
1833 return;
1834 }
1835 // (1) == null
1836 runString = "(1)";
1837 if (null != jtt.bytecode.BC_aaload.test(1)) {
1838 fail(runString);
1839 return;
1840 }
1841 // (2) == ""
1842 runString = "(2)";
1843 if (!"".equals(jtt.bytecode.BC_aaload.test(2))) {
1844 fail(runString);
1845 return;
1846 }
1847 } catch (Throwable t) {
1848 fail(runString, t);
1849 return;
1850 }
1851 pass();
1852 }
1853
1854 static void jtt_bytecode_BC_aaload_1() {
1855 begin("jtt.bytecode.BC_aaload_1");
1856 String runString = null;
1857 try {
1858 // (0) == null
1859 runString = "(0)";
1860 if (null != jtt.bytecode.BC_aaload_1.test(0)) {
1861 fail(runString);
1862 return;
1863 }
1864 // (1) == null
1865 runString = "(1)";
1866 if (null != jtt.bytecode.BC_aaload_1.test(1)) {
1867 fail(runString);
1868 return;
1869 }
1870 // (2) == ""
1871 runString = "(2)";
1872 if (!"".equals(jtt.bytecode.BC_aaload_1.test(2))) {
1873 fail(runString);
1874 return;
1875 }
1876 } catch (Throwable t) {
1877 fail(runString, t);
1878 return;
1879 }
1880 pass();
1881 }
1882
1883 static void jtt_bytecode_BC_aastore() {
1884 begin("jtt.bytecode.BC_aastore");
1885 String runString = null;
1886 try {
1887 // (true,0) == 0
1888 runString = "(true,0)";
1889 if (0 != jtt.bytecode.BC_aastore.test(true, 0)) {
1890 fail(runString);
1891 return;
1892 }
1893 // (true,1) == 1
1894 runString = "(true,1)";
1895 if (1 != jtt.bytecode.BC_aastore.test(true, 1)) {
1896 fail(runString);
1897 return;
1898 }
1899 // (true,2) == 2
1900 runString = "(true,2)";
1901 if (2 != jtt.bytecode.BC_aastore.test(true, 2)) {
1902 fail(runString);
1903 return;
1904 }
1905 // (false,1) == 1
1906 runString = "(false,1)";
1907 if (1 != jtt.bytecode.BC_aastore.test(false, 1)) {
1908 fail(runString);
1909 return;
1910 }
1911 // (false,2) == 2
1912 runString = "(false,2)";
1913 if (2 != jtt.bytecode.BC_aastore.test(false, 2)) {
1914 fail(runString);
1915 return;
1916 }
1917 } catch (Throwable t) {
1918 fail(runString, t);
1919 return;
1920 }
1921 pass();
1922 }
1923
1924 static void jtt_bytecode_BC_aload_0() {
1925 begin("jtt.bytecode.BC_aload_0");
1926 String runString = null;
1927 try {
1928 // (null) == null
1929 runString = "(null)";
1930 if (null != jtt.bytecode.BC_aload_0.test(null)) {
1931 fail(runString);
1932 return;
1933 }
1934 // ("x") == "x"
1935 runString = "(\"x\")";
1936 if (!"x".equals(jtt.bytecode.BC_aload_0.test("x"))) {
1937 fail(runString);
1938 return;
1939 }
1940 } catch (Throwable t) {
1941 fail(runString, t);
1942 return;
1943 }
1944 pass();
1945 }
1946
1947 static void jtt_bytecode_BC_aload_1() {
1948 begin("jtt.bytecode.BC_aload_1");
1949 String runString = null;
1950 try {
1951 // (1,null) == null
1952 runString = "(1,null)";
1953 if (null != jtt.bytecode.BC_aload_1.test(1, null)) {
1954 fail(runString);
1955 return;
1956 }
1957 // (1,"x") == "x"
1958 runString = "(1,\"x\")";
1959 if (!"x".equals(jtt.bytecode.BC_aload_1.test(1, "x"))) {
1960 fail(runString);
1961 return;
1962 }
1963 } catch (Throwable t) {
1964 fail(runString, t);
1965 return;
1966 }
1967 pass();
1968 }
1969
1970 static void jtt_bytecode_BC_aload_2() {
1971 begin("jtt.bytecode.BC_aload_2");
1972 String runString = null;
1973 try {
1974 // (1,1,null) == null
1975 runString = "(1,1,null)";
1976 if (null != jtt.bytecode.BC_aload_2.test(1, 1, null)) {
1977 fail(runString);
1978 return;
1979 }
1980 // (1,1,"x") == "x"
1981 runString = "(1,1,\"x\")";
1982 if (!"x".equals(jtt.bytecode.BC_aload_2.test(1, 1, "x"))) {
1983 fail(runString);
1984 return;
1985 }
1986 } catch (Throwable t) {
1987 fail(runString, t);
1988 return;
1989 }
1990 pass();
1991 }
1992
1993 static void jtt_bytecode_BC_aload_3() {
1994 begin("jtt.bytecode.BC_aload_3");
1995 String runString = null;
1996 try {
1997 // (1,1,1,"x") == "x"
1998 runString = "(1,1,1,\"x\")";
1999 if (!"x".equals(jtt.bytecode.BC_aload_3.test(1, 1, 1, "x"))) {
2000 fail(runString);
2001 return;
2002 }
2003 // (1,1,1,null) == null
2004 runString = "(1,1,1,null)";
2005 if (null != jtt.bytecode.BC_aload_3.test(1, 1, 1, null)) {
2006 fail(runString);
2007 return;
2008 }
2009 } catch (Throwable t) {
2010 fail(runString, t);
2011 return;
2012 }
2013 pass();
2014 }
2015
2016 static void jtt_bytecode_BC_anewarray() {
2017 begin("jtt.bytecode.BC_anewarray");
2018 String runString = null;
2019 try {
2020 // (0) == 0
2021 runString = "(0)";
2022 if (0 != jtt.bytecode.BC_anewarray.test(0)) {
2023 fail(runString);
2024 return;
2025 }
2026 // (1) == 1
2027 runString = "(1)";
2028 if (1 != jtt.bytecode.BC_anewarray.test(1)) {
2029 fail(runString);
2030 return;
2031 }
2032 } catch (Throwable t) {
2033 fail(runString, t);
2034 return;
2035 }
2036 pass();
2037 }
2038
2039 static void jtt_bytecode_BC_areturn() {
2040 begin("jtt.bytecode.BC_areturn");
2041 String runString = null;
2042 try {
2043 // (null) == null
2044 runString = "(null)";
2045 if (null != jtt.bytecode.BC_areturn.test(null)) {
2046 fail(runString);
2047 return;
2048 }
2049 // ("") == ""
2050 runString = "(\"\")";
2051 if (!"".equals(jtt.bytecode.BC_areturn.test(""))) {
2052 fail(runString);
2053 return;
2054 }
2055 // ("this") == "this"
2056 runString = "(\"this\")";
2057 if (!"this".equals(jtt.bytecode.BC_areturn.test("this"))) {
2058 fail(runString);
2059 return;
2060 }
2061 } catch (Throwable t) {
2062 fail(runString, t);
2063 return;
2064 }
2065 pass();
2066 }
2067
2068 static void jtt_bytecode_BC_arraylength() {
2069 begin("jtt.bytecode.BC_arraylength");
2070 String runString = null;
2071 try {
2072 // (1) == 3
2073 runString = "(1)";
2074 if (3 != jtt.bytecode.BC_arraylength.test(1)) {
2075 fail(runString);
2076 return;
2077 }
2078 // (2) == 4
2079 runString = "(2)";
2080 if (4 != jtt.bytecode.BC_arraylength.test(2)) {
2081 fail(runString);
2082 return;
2083 }
2084 // (3) == 5
2085 runString = "(3)";
2086 if (5 != jtt.bytecode.BC_arraylength.test(3)) {
2087 fail(runString);
2088 return;
2089 }
2090 // (4) == 5
2091 runString = "(4)";
2092 if (5 != jtt.bytecode.BC_arraylength.test(4)) {
2093 fail(runString);
2094 return;
2095 }
2096 // (5) == 42
2097 runString = "(5)";
2098 if (42 != jtt.bytecode.BC_arraylength.test(5)) {
2099 fail(runString);
2100 return;
2101 }
2102 } catch (Throwable t) {
2103 fail(runString, t);
2104 return;
2105 }
2106 pass();
2107 }
2108
2109 static void jtt_bytecode_BC_athrow() {
2110 begin("jtt.bytecode.BC_athrow");
2111 String runString = null;
2112 try {
2113 // (0) == 0
2114 runString = "(0)";
2115 if (0 != jtt.bytecode.BC_athrow.test(0)) {
2116 fail(runString);
2117 return;
2118 }
2119 // (1) == 1
2120 runString = "(1)";
2121 if (1 != jtt.bytecode.BC_athrow.test(1)) {
2122 fail(runString);
2123 return;
2124 }
2125 // (2) == !java.lang.Throwable
2126 try {
2127 runString = "(2)";
2128 jtt.bytecode.BC_athrow.test(2);
2129 fail(runString);
2130 return;
2131 } catch (Throwable e) {
2132 if (e.getClass() != java.lang.Throwable.class) {
2133 fail(runString, e);
2134 return;
2135 }
2136 }
2137 // (3) == 3
2138 runString = "(3)";
2139 if (3 != jtt.bytecode.BC_athrow.test(3)) {
2140 fail(runString);
2141 return;
2142 }
2143 } catch (Throwable t) {
2144 fail(runString, t);
2145 return;
2146 }
2147 pass();
2148 }
2149
2150 static void jtt_bytecode_BC_baload() {
2151 begin("jtt.bytecode.BC_baload");
2152 String runString = null;
2153 try {
2154 // (0) == true
2155 runString = "(0)";
2156 if (true != jtt.bytecode.BC_baload.test(0)) {
2157 fail(runString);
2158 return;
2159 }
2160 // (1) == false
2161 runString = "(1)";
2162 if (false != jtt.bytecode.BC_baload.test(1)) {
2163 fail(runString);
2164 return;
2165 }
2166 // (2) == true
2167 runString = "(2)";
2168 if (true != jtt.bytecode.BC_baload.test(2)) {
2169 fail(runString);
2170 return;
2171 }
2172 // (3) == false
2173 runString = "(3)";
2174 if (false != jtt.bytecode.BC_baload.test(3)) {
2175 fail(runString);
2176 return;
2177 }
2178 } catch (Throwable t) {
2179 fail(runString, t);
2180 return;
2181 }
2182 pass();
2183 }
2184
2185 static void jtt_bytecode_BC_bastore() {
2186 begin("jtt.bytecode.BC_bastore");
2187 String runString = null;
2188 try {
2189 // (0,true) == true
2190 runString = "(0,true)";
2191 if (true != jtt.bytecode.BC_bastore.test(0, true)) {
2192 fail(runString);
2193 return;
2194 }
2195 // (1,false) == false
2196 runString = "(1,false)";
2197 if (false != jtt.bytecode.BC_bastore.test(1, false)) {
2198 fail(runString);
2199 return;
2200 }
2201 // (2,true) == true
2202 runString = "(2,true)";
2203 if (true != jtt.bytecode.BC_bastore.test(2, true)) {
2204 fail(runString);
2205 return;
2206 }
2207 // (3,false) == false
2208 runString = "(3,false)";
2209 if (false != jtt.bytecode.BC_bastore.test(3, false)) {
2210 fail(runString);
2211 return;
2212 }
2213 } catch (Throwable t) {
2214 fail(runString, t);
2215 return;
2216 }
2217 pass();
2218 }
2219
2220 static void jtt_bytecode_BC_caload() {
2221 begin("jtt.bytecode.BC_caload");
2222 String runString = null;
2223 try {
2224 // (0) == '\0'
2225 runString = "(0)";
2226 if ((char) 0 != jtt.bytecode.BC_caload.test(0)) {
2227 fail(runString);
2228 return;
2229 }
2230 // (1) == 'a'
2231 runString = "(1)";
2232 if ((char) 97 != jtt.bytecode.BC_caload.test(1)) {
2233 fail(runString);
2234 return;
2235 }
2236 // (2) == ' '
2237 runString = "(2)";
2238 if ((char) 32 != jtt.bytecode.BC_caload.test(2)) {
2239 fail(runString);
2240 return;
2241 }
2242 // (3) == '\23420'
2243 runString = "(3)";
2244 if ((char) 10000 != jtt.bytecode.BC_caload.test(3)) {
2245 fail(runString);
2246 return;
2247 }
2248 } catch (Throwable t) {
2249 fail(runString, t);
2250 return;
2251 }
2252 pass();
2253 }
2254
2255 static void jtt_bytecode_BC_castore() {
2256 begin("jtt.bytecode.BC_castore");
2257 String runString = null;
2258 try {
2259 // (0,'a') == 'a'
2260 runString = "(0,'a')";
2261 if ((char) 97 != jtt.bytecode.BC_castore.test(0, (char) 97)) {
2262 fail(runString);
2263 return;
2264 }
2265 // (1,'A') == 'A'
2266 runString = "(1,'A')";
2267 if ((char) 65 != jtt.bytecode.BC_castore.test(1, (char) 65)) {
2268 fail(runString);
2269 return;
2270 }
2271 // (2,'*') == '*'
2272 runString = "(2,'*')";
2273 if ((char) 42 != jtt.bytecode.BC_castore.test(2, (char) 42)) {
2274 fail(runString);
2275 return;
2276 }
2277 // (3,'x') == 'x'
2278 runString = "(3,'x')";
2279 if ((char) 120 != jtt.bytecode.BC_castore.test(3, (char) 120)) {
2280 fail(runString);
2281 return;
2282 }
2283 } catch (Throwable t) {
2284 fail(runString, t);
2285 return;
2286 }
2287 pass();
2288 }
2289
2290 static void jtt_bytecode_BC_checkcast01() {
2291 begin("jtt.bytecode.BC_checkcast01");
2292 String runString = null;
2293 try {
2294 // (0) == -1
2295 runString = "(0)";
2296 if (-1 != jtt.bytecode.BC_checkcast01.test(0)) {
2297 fail(runString);
2298 return;
2299 }
2300 // (1) == -1
2301 runString = "(1)";
2302 if (-1 != jtt.bytecode.BC_checkcast01.test(1)) {
2303 fail(runString);
2304 return;
2305 }
2306 // (4) == 4
2307 runString = "(4)";
2308 if (4 != jtt.bytecode.BC_checkcast01.test(4)) {
2309 fail(runString);
2310 return;
2311 }
2312 } catch (Throwable t) {
2313 fail(runString, t);
2314 return;
2315 }
2316 pass();
2317 }
2318
2319 static void jtt_bytecode_BC_checkcast02() {
2320 begin("jtt.bytecode.BC_checkcast02");
2321 String runString = null;
2322 try {
2323 // (0) == -1
2324 runString = "(0)";
2325 if (-1 != jtt.bytecode.BC_checkcast02.test(0)) {
2326 fail(runString);
2327 return;
2328 }
2329 // (1) == -1
2330 runString = "(1)";
2331 if (-1 != jtt.bytecode.BC_checkcast02.test(1)) {
2332 fail(runString);
2333 return;
2334 }
2335 // (2) == -1
2336 runString = "(2)";
2337 if (-1 != jtt.bytecode.BC_checkcast02.test(2)) {
2338 fail(runString);
2339 return;
2340 }
2341 // (3) == -1
2342 runString = "(3)";
2343 if (-1 != jtt.bytecode.BC_checkcast02.test(3)) {
2344 fail(runString);
2345 return;
2346 }
2347 } catch (Throwable t) {
2348 fail(runString, t);
2349 return;
2350 }
2351 pass();
2352 }
2353
2354 static void jtt_bytecode_BC_d2f() {
2355 begin("jtt.bytecode.BC_d2f");
2356 String runString = null;
2357 try {
2358 // (0.0) == 0.0
2359 runString = "(0.0)";
2360 if (0.0f != jtt.bytecode.BC_d2f.test(0.0)) {
2361 fail(runString);
2362 return;
2363 }
2364 // (1.0) == 1.0
2365 runString = "(1.0)";
2366 if (1.0f != jtt.bytecode.BC_d2f.test(1.0)) {
2367 fail(runString);
2368 return;
2369 }
2370 // (-1.06) == -1.06
2371 runString = "(-1.06)";
2372 if (-1.06f != jtt.bytecode.BC_d2f.test(-1.06)) {
2373 fail(runString);
2374 return;
2375 }
2376 } catch (Throwable t) {
2377 fail(runString, t);
2378 return;
2379 }
2380 pass();
2381 }
2382
2383 static void jtt_bytecode_BC_d2i01() {
2384 begin("jtt.bytecode.BC_d2i01");
2385 String runString = null;
2386 try {
2387 // (0.0) == 0
2388 runString = "(0.0)";
2389 if (0 != jtt.bytecode.BC_d2i01.test(0.0)) {
2390 fail(runString);
2391 return;
2392 }
2393 // (1.0) == 1
2394 runString = "(1.0)";
2395 if (1 != jtt.bytecode.BC_d2i01.test(1.0)) {
2396 fail(runString);
2397 return;
2398 }
2399 // (-1.06) == -1
2400 runString = "(-1.06)";
2401 if (-1 != jtt.bytecode.BC_d2i01.test(-1.06)) {
2402 fail(runString);
2403 return;
2404 }
2405 // (-156.82743) == -156
2406 runString = "(-156.82743)";
2407 if (-156 != jtt.bytecode.BC_d2i01.test(-156.82743)) {
2408 fail(runString);
2409 return;
2410 }
2411 } catch (Throwable t) {
2412 fail(runString, t);
2413 return;
2414 }
2415 pass();
2416 }
2417
2418 static void jtt_bytecode_BC_d2i02() {
2419 begin("jtt.bytecode.BC_d2i02");
2420 String runString = null;
2421 try {
2422 // (0) == -2147483648
2423 runString = "(0)";
2424 if (-2147483648 != jtt.bytecode.BC_d2i02.test(0)) {
2425 fail(runString);
2426 return;
2427 }
2428 } catch (Throwable t) {
2429 fail(runString, t);
2430 return;
2431 }
2432 pass();
2433 }
2434
2435 static void jtt_bytecode_BC_d2l01() {
2436 begin("jtt.bytecode.BC_d2l01");
2437 String runString = null;
2438 try {
2439 // (0.0) == 0
2440 runString = "(0.0)";
2441 if (0L != jtt.bytecode.BC_d2l01.test(0.0)) {
2442 fail(runString);
2443 return;
2444 }
2445 // (1.0) == 1
2446 runString = "(1.0)";
2447 if (1L != jtt.bytecode.BC_d2l01.test(1.0)) {
2448 fail(runString);
2449 return;
2450 }
2451 // (-1.06) == -1
2452 runString = "(-1.06)";
2453 if (-1L != jtt.bytecode.BC_d2l01.test(-1.06)) {
2454 fail(runString);
2455 return;
2456 }
2457 // (-156.82743) == -156
2458 runString = "(-156.82743)";
2459 if (-156L != jtt.bytecode.BC_d2l01.test(-156.82743)) {
2460 fail(runString);
2461 return;
2462 }
2463 } catch (Throwable t) {
2464 fail(runString, t);
2465 return;
2466 }
2467 pass();
2468 }
2469
2470 static void jtt_bytecode_BC_d2l02() {
2471 begin("jtt.bytecode.BC_d2l02");
2472 String runString = null;
2473 try {
2474 // (0) == -9223372036854775808
2475 runString = "(0)";
2476 if (-9223372036854775808L != jtt.bytecode.BC_d2l02.test(0)) {
2477 fail(runString);
2478 return;
2479 }
2480 } catch (Throwable t) {
2481 fail(runString, t);
2482 return;
2483 }
2484 pass();
2485 }
2486
2487 static void jtt_bytecode_BC_dadd() {
2488 begin("jtt.bytecode.BC_dadd");
2489 String runString = null;
2490 try {
2491 // (0.0,0.0) == 0.0
2492 runString = "(0.0,0.0)";
2493 if (0.0 != jtt.bytecode.BC_dadd.test(0.0, 0.0)) {
2494 fail(runString);
2495 return;
2496 }
2497 // (1.0,1.0) == 2.0
2498 runString = "(1.0,1.0)";
2499 if (2.0 != jtt.bytecode.BC_dadd.test(1.0, 1.0)) {
2500 fail(runString);
2501 return;
2502 }
2503 // (253.11,54.43) == 307.54
2504 runString = "(253.11,54.43)";
2505 if (307.54 != jtt.bytecode.BC_dadd.test(253.11, 54.43)) {
2506 fail(runString);
2507 return;
2508 }
2509 } catch (Throwable t) {
2510 fail(runString, t);
2511 return;
2512 }
2513 pass();
2514 }
2515
2516 static void jtt_bytecode_BC_daload() {
2517 begin("jtt.bytecode.BC_daload");
2518 String runString = null;
2519 try {
2520 // (0) == 0.0
2521 runString = "(0)";
2522 if (0.0 != jtt.bytecode.BC_daload.test(0)) {
2523 fail(runString);
2524 return;
2525 }
2526 // (1) == -1.1
2527 runString = "(1)";
2528 if (-1.1 != jtt.bytecode.BC_daload.test(1)) {
2529 fail(runString);
2530 return;
2531 }
2532 // (2) == 4.32
2533 runString = "(2)";
2534 if (4.32 != jtt.bytecode.BC_daload.test(2)) {
2535 fail(runString);
2536 return;
2537 }
2538 // (3) == 6.06
2539 runString = "(3)";
2540 if (6.06 != jtt.bytecode.BC_daload.test(3)) {
2541 fail(runString);
2542 return;
2543 }
2544 } catch (Throwable t) {
2545 fail(runString, t);
2546 return;
2547 }
2548 pass();
2549 }
2550
2551 static void jtt_bytecode_BC_dastore() {
2552 begin("jtt.bytecode.BC_dastore");
2553 String runString = null;
2554 try {
2555 // (0,0.01) == 0.01
2556 runString = "(0,0.01)";
2557 if (0.01 != jtt.bytecode.BC_dastore.test(0, 0.01)) {
2558 fail(runString);
2559 return;
2560 }
2561 // (1,-1.4) == -1.4
2562 runString = "(1,-1.4)";
2563 if (-1.4 != jtt.bytecode.BC_dastore.test(1, -1.4)) {
2564 fail(runString);
2565 return;
2566 }
2567 // (2,0.01) == 0.01
2568 runString = "(2,0.01)";
2569 if (0.01 != jtt.bytecode.BC_dastore.test(2, 0.01)) {
2570 fail(runString);
2571 return;
2572 }
2573 // (3,-1.4) == -1.4
2574 runString = "(3,-1.4)";
2575 if (-1.4 != jtt.bytecode.BC_dastore.test(3, -1.4)) {
2576 fail(runString);
2577 return;
2578 }
2579 } catch (Throwable t) {
2580 fail(runString, t);
2581 return;
2582 }
2583 pass();
2584 }
2585
2586 static void jtt_bytecode_BC_dcmp01() {
2587 begin("jtt.bytecode.BC_dcmp01");
2588 String runString = null;
2589 try {
2590 // (0.0,-0.1) == false
2591 runString = "(0.0,-0.1)";
2592 if (false != jtt.bytecode.BC_dcmp01.test(0.0, -0.1)) {
2593 fail(runString);
2594 return;
2595 }
2596 // (78.0,78.001) == true
2597 runString = "(78.0,78.001)";
2598 if (true != jtt.bytecode.BC_dcmp01.test(78.0, 78.001)) {
2599 fail(runString);
2600 return;
2601 }
2602 } catch (Throwable t) {
2603 fail(runString, t);
2604 return;
2605 }
2606 pass();
2607 }
2608
2609 static void jtt_bytecode_BC_dcmp02() {
2610 begin("jtt.bytecode.BC_dcmp02");
2611 String runString = null;
2612 try {
2613 // (-1.0) == false
2614 runString = "(-1.0)";
2615 if (false != jtt.bytecode.BC_dcmp02.test(-1.0)) {
2616 fail(runString);
2617 return;
2618 }
2619 // (1.0) == false
2620 runString = "(1.0)";
2621 if (false != jtt.bytecode.BC_dcmp02.test(1.0)) {
2622 fail(runString);
2623 return;
2624 }
2625 // (0.0) == false
2626 runString = "(0.0)";
2627 if (false != jtt.bytecode.BC_dcmp02.test(0.0)) {
2628 fail(runString);
2629 return;
2630 }
2631 // (-0.0) == false
2632 runString = "(-0.0)";
2633 if (false != jtt.bytecode.BC_dcmp02.test(-0.0)) {
2634 fail(runString);
2635 return;
2636 }
2637 } catch (Throwable t) {
2638 fail(runString, t);
2639 return;
2640 }
2641 pass();
2642 }
2643
2644 static void jtt_bytecode_BC_dcmp03() {
2645 begin("jtt.bytecode.BC_dcmp03");
2646 String runString = null;
2647 try {
2648 // (-1.0) == true
2649 runString = "(-1.0)";
2650 if (true != jtt.bytecode.BC_dcmp03.test(-1.0)) {
2651 fail(runString);
2652 return;
2653 }
2654 // (1.0) == true
2655 runString = "(1.0)";
2656 if (true != jtt.bytecode.BC_dcmp03.test(1.0)) {
2657 fail(runString);
2658 return;
2659 }
2660 // (0.0) == false
2661 runString = "(0.0)";
2662 if (false != jtt.bytecode.BC_dcmp03.test(0.0)) {
2663 fail(runString);
2664 return;
2665 }
2666 // (-0.0) == false
2667 runString = "(-0.0)";
2668 if (false != jtt.bytecode.BC_dcmp03.test(-0.0)) {
2669 fail(runString);
2670 return;
2671 }
2672 } catch (Throwable t) {
2673 fail(runString, t);
2674 return;
2675 }
2676 pass();
2677 }
2678
2679 static void jtt_bytecode_BC_dcmp04() {
2680 begin("jtt.bytecode.BC_dcmp04");
2681 String runString = null;
2682 try {
2683 // (-1.0) == false
2684 runString = "(-1.0)";
2685 if (false != jtt.bytecode.BC_dcmp04.test(-1.0)) {
2686 fail(runString);
2687 return;
2688 }
2689 // (1.0) == false
2690 runString = "(1.0)";
2691 if (false != jtt.bytecode.BC_dcmp04.test(1.0)) {
2692 fail(runString);
2693 return;
2694 }
2695 // (0.0) == false
2696 runString = "(0.0)";
2697 if (false != jtt.bytecode.BC_dcmp04.test(0.0)) {
2698 fail(runString);
2699 return;
2700 }
2701 // (-0.0) == false
2702 runString = "(-0.0)";
2703 if (false != jtt.bytecode.BC_dcmp04.test(-0.0)) {
2704 fail(runString);
2705 return;
2706 }
2707 } catch (Throwable t) {
2708 fail(runString, t);
2709 return;
2710 }
2711 pass();
2712 }
2713
2714 static void jtt_bytecode_BC_dcmp05() {
2715 begin("jtt.bytecode.BC_dcmp05");
2716 String runString = null;
2717 try {
2718 // (-1.0) == true
2719 runString = "(-1.0)";
2720 if (true != jtt.bytecode.BC_dcmp05.test(-1.0)) {
2721 fail(runString);
2722 return;
2723 }
2724 // (1.0) == true
2725 runString = "(1.0)";
2726 if (true != jtt.bytecode.BC_dcmp05.test(1.0)) {
2727 fail(runString);
2728 return;
2729 }
2730 // (0.0) == false
2731 runString = "(0.0)";
2732 if (false != jtt.bytecode.BC_dcmp05.test(0.0)) {
2733 fail(runString);
2734 return;
2735 }
2736 } catch (Throwable t) {
2737 fail(runString, t);
2738 return;
2739 }
2740 pass();
2741 }
2742
2743 static void jtt_bytecode_BC_dcmp06() {
2744 begin("jtt.bytecode.BC_dcmp06");
2745 String runString = null;
2746 try {
2747 // (-1.0) == true
2748 runString = "(-1.0)";
2749 if (true != jtt.bytecode.BC_dcmp06.test(-1.0)) {
2750 fail(runString);
2751 return;
2752 }
2753 // (1.0) == true
2754 runString = "(1.0)";
2755 if (true != jtt.bytecode.BC_dcmp06.test(1.0)) {
2756 fail(runString);
2757 return;
2758 }
2759 // (0.0) == false
2760 runString = "(0.0)";
2761 if (false != jtt.bytecode.BC_dcmp06.test(0.0)) {
2762 fail(runString);
2763 return;
2764 }
2765 } catch (Throwable t) {
2766 fail(runString, t);
2767 return;
2768 }
2769 pass();
2770 }
2771
2772 static void jtt_bytecode_BC_dcmp07() {
2773 begin("jtt.bytecode.BC_dcmp07");
2774 String runString = null;
2775 try {
2776 // (-1.0) == false
2777 runString = "(-1.0)";
2778 if (false != jtt.bytecode.BC_dcmp07.test(-1.0)) {
2779 fail(runString);
2780 return;
2781 }
2782 // (1.0) == false
2783 runString = "(1.0)";
2784 if (false != jtt.bytecode.BC_dcmp07.test(1.0)) {
2785 fail(runString);
2786 return;
2787 }
2788 // (0.0) == false
2789 runString = "(0.0)";
2790 if (false != jtt.bytecode.BC_dcmp07.test(0.0)) {
2791 fail(runString);
2792 return;
2793 }
2794 } catch (Throwable t) {
2795 fail(runString, t);
2796 return;
2797 }
2798 pass();
2799 }
2800
2801 static void jtt_bytecode_BC_dcmp08() {
2802 begin("jtt.bytecode.BC_dcmp08");
2803 String runString = null;
2804 try {
2805 // (-1.0) == true
2806 runString = "(-1.0)";
2807 if (true != jtt.bytecode.BC_dcmp08.test(-1.0)) {
2808 fail(runString);
2809 return;
2810 }
2811 // (1.0) == true
2812 runString = "(1.0)";
2813 if (true != jtt.bytecode.BC_dcmp08.test(1.0)) {
2814 fail(runString);
2815 return;
2816 }
2817 // (0.0) == false
2818 runString = "(0.0)";
2819 if (false != jtt.bytecode.BC_dcmp08.test(0.0)) {
2820 fail(runString);
2821 return;
2822 }
2823 } catch (Throwable t) {
2824 fail(runString, t);
2825 return;
2826 }
2827 pass();
2828 }
2829
2830 static void jtt_bytecode_BC_dcmp09() {
2831 begin("jtt.bytecode.BC_dcmp09");
2832 String runString = null;
2833 try {
2834 // (-1.0) == false
2835 runString = "(-1.0)";
2836 if (false != jtt.bytecode.BC_dcmp09.test(-1.0)) {
2837 fail(runString);
2838 return;
2839 }
2840 // (1.0) == false
2841 runString = "(1.0)";
2842 if (false != jtt.bytecode.BC_dcmp09.test(1.0)) {
2843 fail(runString);
2844 return;
2845 }
2846 // (0.0) == false
2847 runString = "(0.0)";
2848 if (false != jtt.bytecode.BC_dcmp09.test(0.0)) {
2849 fail(runString);
2850 return;
2851 }
2852 } catch (Throwable t) {
2853 fail(runString, t);
2854 return;
2855 }
2856 pass();
2857 }
2858
2859 static void jtt_bytecode_BC_dcmp10() {
2860 begin("jtt.bytecode.BC_dcmp10");
2861 String runString = null;
2862 try {
2863 // (0) == false
2864 runString = "(0)";
2865 if (false != jtt.bytecode.BC_dcmp10.test(0)) {
2866 fail(runString);
2867 return;
2868 }
2869 // (1) == true
2870 runString = "(1)";
2871 if (true != jtt.bytecode.BC_dcmp10.test(1)) {
2872 fail(runString);
2873 return;
2874 }
2875 // (2) == true
2876 runString = "(2)";
2877 if (true != jtt.bytecode.BC_dcmp10.test(2)) {
2878 fail(runString);
2879 return;
2880 }
2881 // (3) == false
2882 runString = "(3)";
2883 if (false != jtt.bytecode.BC_dcmp10.test(3)) {
2884 fail(runString);
2885 return;
2886 }
2887 // (4) == true
2888 runString = "(4)";
2889 if (true != jtt.bytecode.BC_dcmp10.test(4)) {
2890 fail(runString);
2891 return;
2892 }
2893 // (5) == true
2894 runString = "(5)";
2895 if (true != jtt.bytecode.BC_dcmp10.test(5)) {
2896 fail(runString);
2897 return;
2898 }
2899 // (6) == false
2900 runString = "(6)";
2901 if (false != jtt.bytecode.BC_dcmp10.test(6)) {
2902 fail(runString);
2903 return;
2904 }
2905 // (7) == false
2906 runString = "(7)";
2907 if (false != jtt.bytecode.BC_dcmp10.test(7)) {
2908 fail(runString);
2909 return;
2910 }
2911 // (8) == false
2912 runString = "(8)";
2913 if (false != jtt.bytecode.BC_dcmp10.test(8)) {
2914 fail(runString);
2915 return;
2916 }
2917 } catch (Throwable t) {
2918 fail(runString, t);
2919 return;
2920 }
2921 pass();
2922 }
2923
2924 static void jtt_bytecode_BC_ddiv() {
2925 begin("jtt.bytecode.BC_ddiv");
2926 String runString = null;
2927 try {
2928 // (311.0,10.0) == 31.1
2929 runString = "(311.0,10.0)";
2930 if (31.1 != jtt.bytecode.BC_ddiv.test(311.0, 10.0)) {
2931 fail(runString);
2932 return;
2933 }
2934 } catch (Throwable t) {
2935 fail(runString, t);
2936 return;
2937 }
2938 pass();
2939 }
2940
2941 static void jtt_bytecode_BC_dmul() {
2942 begin("jtt.bytecode.BC_dmul");
2943 String runString = null;
2944 try {
2945 // (311.0,10.0) == 3110.0
2946 runString = "(311.0,10.0)";
2947 if (3110.0 != jtt.bytecode.BC_dmul.test(311.0, 10.0)) {
2948 fail(runString);
2949 return;
2950 }
2951 } catch (Throwable t) {
2952 fail(runString, t);
2953 return;
2954 }
2955 pass();
2956 }
2957
2958 static void jtt_bytecode_BC_dneg() {
2959 begin("jtt.bytecode.BC_dneg");
2960 String runString = null;
2961 try {
2962 // (0.0) == -0.0
2963 runString = "(0.0)";
2964 if (-0.0 != jtt.bytecode.BC_dneg.test(0.0)) {
2965 fail(runString);
2966 return;
2967 }
2968 // (-1.01) == 1.01
2969 runString = "(-1.01)";
2970 if (1.01 != jtt.bytecode.BC_dneg.test(-1.01)) {
2971 fail(runString);
2972 return;
2973 }
2974 // (7263.8734) == -7263.8734
2975 runString = "(7263.8734)";
2976 if (-7263.8734 != jtt.bytecode.BC_dneg.test(7263.8734)) {
2977 fail(runString);
2978 return;
2979 }
2980 } catch (Throwable t) {
2981 fail(runString, t);
2982 return;
2983 }
2984 pass();
2985 }
2986
2987 static void jtt_bytecode_BC_drem() {
2988 begin("jtt.bytecode.BC_drem");
2989 String runString = null;
2990 try {
2991 // (311.0,10.0) == 1.0
2992 runString = "(311.0,10.0)";
2993 if (1.0 != jtt.bytecode.BC_drem.test(311.0, 10.0)) {
2994 fail(runString);
2995 return;
2996 }
2997 } catch (Throwable t) {
2998 fail(runString, t);
2999 return;
3000 }
3001 pass();
3002 }
3003
3004 static void jtt_bytecode_BC_dreturn() {
3005 begin("jtt.bytecode.BC_dreturn");
3006 String runString = null;
3007 try {
3008 // (0.0) == 0.0
3009 runString = "(0.0)";
3010 if (0.0 != jtt.bytecode.BC_dreturn.test(0.0)) {
3011 fail(runString);
3012 return;
3013 }
3014 // (1.1) == 1.1
3015 runString = "(1.1)";
3016 if (1.1 != jtt.bytecode.BC_dreturn.test(1.1)) {
3017 fail(runString);
3018 return;
3019 }
3020 // (-1.4) == -1.4
3021 runString = "(-1.4)";
3022 if (-1.4 != jtt.bytecode.BC_dreturn.test(-1.4)) {
3023 fail(runString);
3024 return;
3025 }
3026 // (256.33) == 256.33
3027 runString = "(256.33)";
3028 if (256.33 != jtt.bytecode.BC_dreturn.test(256.33)) {
3029 fail(runString);
3030 return;
3031 }
3032 // (1000.001) == 1000.001
3033 runString = "(1000.001)";
3034 if (1000.001 != jtt.bytecode.BC_dreturn.test(1000.001)) {
3035 fail(runString);
3036 return;
3037 }
3038 } catch (Throwable t) {
3039 fail(runString, t);
3040 return;
3041 }
3042 pass();
3043 }
3044
3045 static void jtt_bytecode_BC_dsub() {
3046 begin("jtt.bytecode.BC_dsub");
3047 String runString = null;
3048 try {
3049 // (0.0,0.0) == 0.0
3050 runString = "(0.0,0.0)";
3051 if (0.0 != jtt.bytecode.BC_dsub.test(0.0, 0.0)) {
3052 fail(runString);
3053 return;
3054 }
3055 // (1.0,1.0) == 0.0
3056 runString = "(1.0,1.0)";
3057 if (0.0 != jtt.bytecode.BC_dsub.test(1.0, 1.0)) {
3058 fail(runString);
3059 return;
3060 }
3061 // (253.11,54.43) == 198.68
3062 runString = "(253.11,54.43)";
3063 if (198.68 != jtt.bytecode.BC_dsub.test(253.11, 54.43)) {
3064 fail(runString);
3065 return;
3066 }
3067 } catch (Throwable t) {
3068 fail(runString, t);
3069 return;
3070 }
3071 pass();
3072 }
3073
3074 static void jtt_bytecode_BC_f2d() {
3075 begin("jtt.bytecode.BC_f2d");
3076 String runString = null;
3077 try {
3078 // (0.0) == 0.0
3079 runString = "(0.0)";
3080 if (0.0 != jtt.bytecode.BC_f2d.test(0.0f)) {
3081 fail(runString);
3082 return;
3083 }
3084 // (1.0) == 1.0
3085 runString = "(1.0)";
3086 if (1.0 != jtt.bytecode.BC_f2d.test(1.0f)) {
3087 fail(runString);
3088 return;
3089 }
3090 // (-2.0) == -2.0
3091 runString = "(-2.0)";
3092 if (-2.0 != jtt.bytecode.BC_f2d.test(-2.0f)) {
3093 fail(runString);
3094 return;
3095 }
3096 } catch (Throwable t) {
3097 fail(runString, t);
3098 return;
3099 }
3100 pass();
3101 }
3102
3103 static void jtt_bytecode_BC_f2i01() {
3104 begin("jtt.bytecode.BC_f2i01");
3105 String runString = null;
3106 try {
3107 // (0.0) == 0
3108 runString = "(0.0)";
3109 if (0 != jtt.bytecode.BC_f2i01.test(0.0f)) {
3110 fail(runString);
3111 return;
3112 }
3113 // (1.0) == 1
3114 runString = "(1.0)";
3115 if (1 != jtt.bytecode.BC_f2i01.test(1.0f)) {
3116 fail(runString);
3117 return;
3118 }
3119 // (-1.06) == -1
3120 runString = "(-1.06)";
3121 if (-1 != jtt.bytecode.BC_f2i01.test(-1.06f)) {
3122 fail(runString);
3123 return;
3124 }
3125 // (-156.82742) == -156
3126 runString = "(-156.82742)";
3127 if (-156 != jtt.bytecode.BC_f2i01.test(-156.82742f)) {
3128 fail(runString);
3129 return;
3130 }
3131 } catch (Throwable t) {
3132 fail(runString, t);
3133 return;
3134 }
3135 pass();
3136 }
3137
3138 static void jtt_bytecode_BC_f2i02() {
3139 begin("jtt.bytecode.BC_f2i02");
3140 String runString = null;
3141 try {
3142 // (0) == -2147483648
3143 runString = "(0)";
3144 if (-2147483648 != jtt.bytecode.BC_f2i02.test(0)) {
3145 fail(runString);
3146 return;
3147 }
3148 } catch (Throwable t) {
3149 fail(runString, t);
3150 return;
3151 }
3152 pass();
3153 }
3154
3155 static void jtt_bytecode_BC_f2l01() {
3156 begin("jtt.bytecode.BC_f2l01");
3157 String runString = null;
3158 try {
3159 // (0.0) == 0
3160 runString = "(0.0)";
3161 if (0L != jtt.bytecode.BC_f2l01.test(0.0f)) {
3162 fail(runString);
3163 return;
3164 }
3165 // (1.0) == 1
3166 runString = "(1.0)";
3167 if (1L != jtt.bytecode.BC_f2l01.test(1.0f)) {
3168 fail(runString);
3169 return;
3170 }
3171 // (-1.06) == -1
3172 runString = "(-1.06)";
3173 if (-1L != jtt.bytecode.BC_f2l01.test(-1.06f)) {
3174 fail(runString);
3175 return;
3176 }
3177 // (-156.82742) == -156
3178 runString = "(-156.82742)";
3179 if (-156L != jtt.bytecode.BC_f2l01.test(-156.82742f)) {
3180 fail(runString);
3181 return;
3182 }
3183 } catch (Throwable t) {
3184 fail(runString, t);
3185 return;
3186 }
3187 pass();
3188 }
3189
3190 static void jtt_bytecode_BC_f2l02() {
3191 begin("jtt.bytecode.BC_f2l02");
3192 String runString = null;
3193 try {
3194 // (0) == -9223372036854775808
3195 runString = "(0)";
3196 if (-9223372036854775808L != jtt.bytecode.BC_f2l02.test(0)) {
3197 fail(runString);
3198 return;
3199 }
3200 } catch (Throwable t) {
3201 fail(runString, t);
3202 return;
3203 }
3204 pass();
3205 }
3206
3207 static void jtt_bytecode_BC_fadd() {
3208 begin("jtt.bytecode.BC_fadd");
3209 String runString = null;
3210 try {
3211 // (0.0,0.0) == 0.0
3212 runString = "(0.0,0.0)";
3213 if (0.0f != jtt.bytecode.BC_fadd.test(0.0f, 0.0f)) {
3214 fail(runString);
3215 return;
3216 }
3217 // (1.0,1.0) == 2.0
3218 runString = "(1.0,1.0)";
3219 if (2.0f != jtt.bytecode.BC_fadd.test(1.0f, 1.0f)) {
3220 fail(runString);
3221 return;
3222 }
3223 // (253.11,54.43) == 307.54
3224 runString = "(253.11,54.43)";
3225 if (307.54f != jtt.bytecode.BC_fadd.test(253.11f, 54.43f)) {
3226 fail(runString);
3227 return;
3228 }
3229 } catch (Throwable t) {
3230 fail(runString, t);
3231 return;
3232 }
3233 pass();
3234 }
3235
3236 static void jtt_bytecode_BC_faload() {
3237 begin("jtt.bytecode.BC_faload");
3238 String runString = null;
3239 try {
3240 // (0) == 0.0
3241 runString = "(0)";
3242 if (0.0f != jtt.bytecode.BC_faload.test(0)) {
3243 fail(runString);
3244 return;
3245 }
3246 // (1) == -1.1
3247 runString = "(1)";
3248 if (-1.1f != jtt.bytecode.BC_faload.test(1)) {
3249 fail(runString);
3250 return;
3251 }
3252 // (2) == 4.32
3253 runString = "(2)";
3254 if (4.32f != jtt.bytecode.BC_faload.test(2)) {
3255 fail(runString);
3256 return;
3257 }
3258 // (3) == 6.06
3259 runString = "(3)";
3260 if (6.06f != jtt.bytecode.BC_faload.test(3)) {
3261 fail(runString);
3262 return;
3263 }
3264 } catch (Throwable t) {
3265 fail(runString, t);
3266 return;
3267 }
3268 pass();
3269 }
3270
3271 static void jtt_bytecode_BC_fastore() {
3272 begin("jtt.bytecode.BC_fastore");
3273 String runString = null;
3274 try {
3275 // (0,0.01) == 0.01
3276 runString = "(0,0.01)";
3277 if (0.01f != jtt.bytecode.BC_fastore.test(0, 0.01f)) {
3278 fail(runString);
3279 return;
3280 }
3281 // (1,-1.4) == -1.4
3282 runString = "(1,-1.4)";
3283 if (-1.4f != jtt.bytecode.BC_fastore.test(1, -1.4f)) {
3284 fail(runString);
3285 return;
3286 }
3287 // (2,0.01) == 0.01
3288 runString = "(2,0.01)";
3289 if (0.01f != jtt.bytecode.BC_fastore.test(2, 0.01f)) {
3290 fail(runString);
3291 return;
3292 }
3293 // (3,-1.4) == -1.4
3294 runString = "(3,-1.4)";
3295 if (-1.4f != jtt.bytecode.BC_fastore.test(3, -1.4f)) {
3296 fail(runString);
3297 return;
3298 }
3299 } catch (Throwable t) {
3300 fail(runString, t);
3301 return;
3302 }
3303 pass();
3304 }
3305
3306 static void jtt_bytecode_BC_fcmp01() {
3307 begin("jtt.bytecode.BC_fcmp01");
3308 String runString = null;
3309 try {
3310 // (0.0,-0.1) == false
3311 runString = "(0.0,-0.1)";
3312 if (false != jtt.bytecode.BC_fcmp01.test(0.0f, -0.1f)) {
3313 fail(runString);
3314 return;
3315 }
3316 // (78.0,78.001) == true
3317 runString = "(78.0,78.001)";
3318 if (true != jtt.bytecode.BC_fcmp01.test(78.0f, 78.001f)) {
3319 fail(runString);
3320 return;
3321 }
3322 } catch (Throwable t) {
3323 fail(runString, t);
3324 return;
3325 }
3326 pass();
3327 }
3328
3329 static void jtt_bytecode_BC_fcmp02() {
3330 begin("jtt.bytecode.BC_fcmp02");
3331 String runString = null;
3332 try {
3333 // (-1.0) == false
3334 runString = "(-1.0)";
3335 if (false != jtt.bytecode.BC_fcmp02.test(-1.0f)) {
3336 fail(runString);
3337 return;
3338 }
3339 // (1.0) == false
3340 runString = "(1.0)";
3341 if (false != jtt.bytecode.BC_fcmp02.test(1.0f)) {
3342 fail(runString);
3343 return;
3344 }
3345 // (0.0) == false
3346 runString = "(0.0)";
3347 if (false != jtt.bytecode.BC_fcmp02.test(0.0f)) {
3348 fail(runString);
3349 return;
3350 }
3351 } catch (Throwable t) {
3352 fail(runString, t);
3353 return;
3354 }
3355 pass();
3356 }
3357
3358 static void jtt_bytecode_BC_fcmp03() {
3359 begin("jtt.bytecode.BC_fcmp03");
3360 String runString = null;
3361 try {
3362 // (-1.0) == true
3363 runString = "(-1.0)";
3364 if (true != jtt.bytecode.BC_fcmp03.test(-1.0f)) {
3365 fail(runString);
3366 return;
3367 }
3368 // (1.0) == true
3369 runString = "(1.0)";
3370 if (true != jtt.bytecode.BC_fcmp03.test(1.0f)) {
3371 fail(runString);
3372 return;
3373 }
3374 // (0.0) == false
3375 runString = "(0.0)";
3376 if (false != jtt.bytecode.BC_fcmp03.test(0.0f)) {
3377 fail(runString);
3378 return;
3379 }
3380 } catch (Throwable t) {
3381 fail(runString, t);
3382 return;
3383 }
3384 pass();
3385 }
3386
3387 static void jtt_bytecode_BC_fcmp04() {
3388 begin("jtt.bytecode.BC_fcmp04");
3389 String runString = null;
3390 try {
3391 // (-1.0) == false
3392 runString = "(-1.0)";
3393 if (false != jtt.bytecode.BC_fcmp04.test(-1.0f)) {
3394 fail(runString);
3395 return;
3396 }
3397 // (1.0) == false
3398 runString = "(1.0)";
3399 if (false != jtt.bytecode.BC_fcmp04.test(1.0f)) {
3400 fail(runString);
3401 return;
3402 }
3403 // (0.0) == false
3404 runString = "(0.0)";
3405 if (false != jtt.bytecode.BC_fcmp04.test(0.0f)) {
3406 fail(runString);
3407 return;
3408 }
3409 } catch (Throwable t) {
3410 fail(runString, t);
3411 return;
3412 }
3413 pass();
3414 }
3415
3416 static void jtt_bytecode_BC_fcmp05() {
3417 begin("jtt.bytecode.BC_fcmp05");
3418 String runString = null;
3419 try {
3420 // (-1.0) == true
3421 runString = "(-1.0)";
3422 if (true != jtt.bytecode.BC_fcmp05.test(-1.0f)) {
3423 fail(runString);
3424 return;
3425 }
3426 // (1.0) == true
3427 runString = "(1.0)";
3428 if (true != jtt.bytecode.BC_fcmp05.test(1.0f)) {
3429 fail(runString);
3430 return;
3431 }
3432 // (0.0) == false
3433 runString = "(0.0)";
3434 if (false != jtt.bytecode.BC_fcmp05.test(0.0f)) {
3435 fail(runString);
3436 return;
3437 }
3438 } catch (Throwable t) {
3439 fail(runString, t);
3440 return;
3441 }
3442 pass();
3443 }
3444
3445 static void jtt_bytecode_BC_fcmp06() {
3446 begin("jtt.bytecode.BC_fcmp06");
3447 String runString = null;
3448 try {
3449 // (-1.0) == true
3450 runString = "(-1.0)";
3451 if (true != jtt.bytecode.BC_fcmp06.test(-1.0f)) {
3452 fail(runString);
3453 return;
3454 }
3455 // (1.0) == true
3456 runString = "(1.0)";
3457 if (true != jtt.bytecode.BC_fcmp06.test(1.0f)) {
3458 fail(runString);
3459 return;
3460 }
3461 // (0.0) == false
3462 runString = "(0.0)";
3463 if (false != jtt.bytecode.BC_fcmp06.test(0.0f)) {
3464 fail(runString);
3465 return;
3466 }
3467 } catch (Throwable t) {
3468 fail(runString, t);
3469 return;
3470 }
3471 pass();
3472 }
3473
3474 static void jtt_bytecode_BC_fcmp07() {
3475 begin("jtt.bytecode.BC_fcmp07");
3476 String runString = null;
3477 try {
3478 // (-1.0) == false
3479 runString = "(-1.0)";
3480 if (false != jtt.bytecode.BC_fcmp07.test(-1.0f)) {
3481 fail(runString);
3482 return;
3483 }
3484 // (1.0) == false
3485 runString = "(1.0)";
3486 if (false != jtt.bytecode.BC_fcmp07.test(1.0f)) {
3487 fail(runString);
3488 return;
3489 }
3490 // (0.0) == false
3491 runString = "(0.0)";
3492 if (false != jtt.bytecode.BC_fcmp07.test(0.0f)) {
3493 fail(runString);
3494 return;
3495 }
3496 } catch (Throwable t) {
3497 fail(runString, t);
3498 return;
3499 }
3500 pass();
3501 }
3502
3503 static void jtt_bytecode_BC_fcmp08() {
3504 begin("jtt.bytecode.BC_fcmp08");
3505 String runString = null;
3506 try {
3507 // (-1.0) == true
3508 runString = "(-1.0)";
3509 if (true != jtt.bytecode.BC_fcmp08.test(-1.0f)) {
3510 fail(runString);
3511 return;
3512 }
3513 // (1.0) == true
3514 runString = "(1.0)";
3515 if (true != jtt.bytecode.BC_fcmp08.test(1.0f)) {
3516 fail(runString);
3517 return;
3518 }
3519 // (0.0) == false
3520 runString = "(0.0)";
3521 if (false != jtt.bytecode.BC_fcmp08.test(0.0f)) {
3522 fail(runString);
3523 return;
3524 }
3525 } catch (Throwable t) {
3526 fail(runString, t);
3527 return;
3528 }
3529 pass();
3530 }
3531
3532 static void jtt_bytecode_BC_fcmp09() {
3533 begin("jtt.bytecode.BC_fcmp09");
3534 String runString = null;
3535 try {
3536 // (-1.0) == false
3537 runString = "(-1.0)";
3538 if (false != jtt.bytecode.BC_fcmp09.test(-1.0f)) {
3539 fail(runString);
3540 return;
3541 }
3542 // (1.0) == false
3543 runString = "(1.0)";
3544 if (false != jtt.bytecode.BC_fcmp09.test(1.0f)) {
3545 fail(runString);
3546 return;
3547 }
3548 // (0.0) == false
3549 runString = "(0.0)";
3550 if (false != jtt.bytecode.BC_fcmp09.test(0.0f)) {
3551 fail(runString);
3552 return;
3553 }
3554 } catch (Throwable t) {
3555 fail(runString, t);
3556 return;
3557 }
3558 pass();
3559 }
3560
3561 static void jtt_bytecode_BC_fcmp10() {
3562 begin("jtt.bytecode.BC_fcmp10");
3563 String runString = null;
3564 try {
3565 // (0) == false
3566 runString = "(0)";
3567 if (false != jtt.bytecode.BC_fcmp10.test(0)) {
3568 fail(runString);
3569 return;
3570 }
3571 // (1) == true
3572 runString = "(1)";
3573 if (true != jtt.bytecode.BC_fcmp10.test(1)) {
3574 fail(runString);
3575 return;
3576 }
3577 // (2) == true
3578 runString = "(2)";
3579 if (true != jtt.bytecode.BC_fcmp10.test(2)) {
3580 fail(runString);
3581 return;
3582 }
3583 // (3) == false
3584 runString = "(3)";
3585 if (false != jtt.bytecode.BC_fcmp10.test(3)) {
3586 fail(runString);
3587 return;
3588 }
3589 // (4) == true
3590 runString = "(4)";
3591 if (true != jtt.bytecode.BC_fcmp10.test(4)) {
3592 fail(runString);
3593 return;
3594 }
3595 // (5) == true
3596 runString = "(5)";
3597 if (true != jtt.bytecode.BC_fcmp10.test(5)) {
3598 fail(runString);
3599 return;
3600 }
3601 // (6) == false
3602 runString = "(6)";
3603 if (false != jtt.bytecode.BC_fcmp10.test(6)) {
3604 fail(runString);
3605 return;
3606 }
3607 // (7) == false
3608 runString = "(7)";
3609 if (false != jtt.bytecode.BC_fcmp10.test(7)) {
3610 fail(runString);
3611 return;
3612 }
3613 // (8) == false
3614 runString = "(8)";
3615 if (false != jtt.bytecode.BC_fcmp10.test(8)) {
3616 fail(runString);
3617 return;
3618 }
3619 } catch (Throwable t) {
3620 fail(runString, t);
3621 return;
3622 }
3623 pass();
3624 }
3625
3626 static void jtt_bytecode_BC_fdiv() {
3627 begin("jtt.bytecode.BC_fdiv");
3628 String runString = null;
3629 try {
3630 // (311.0,10.0) == 31.1
3631 runString = "(311.0,10.0)";
3632 if (31.1f != jtt.bytecode.BC_fdiv.test(311.0f, 10.0f)) {
3633 fail(runString);
3634 return;
3635 }
3636 } catch (Throwable t) {
3637 fail(runString, t);
3638 return;
3639 }
3640 pass();
3641 }
3642
3643 static void jtt_bytecode_BC_fload() {
3644 begin("jtt.bytecode.BC_fload");
3645 String runString = null;
3646 try {
3647 // (-1.0) == -1.0
3648 runString = "(-1.0)";
3649 if (-1.0f != jtt.bytecode.BC_fload.test(-1.0f)) {
3650 fail(runString);
3651 return;
3652 }
3653 // (-1.01) == -1.01
3654 runString = "(-1.01)";
3655 if (-1.01f != jtt.bytecode.BC_fload.test(-1.01f)) {
3656 fail(runString);
3657 return;
3658 }
3659 } catch (Throwable t) {
3660 fail(runString, t);
3661 return;
3662 }
3663 pass();
3664 }
3665
3666 static void jtt_bytecode_BC_fload_2() {
3667 begin("jtt.bytecode.BC_fload_2");
3668 String runString = null;
3669 try {
3670 // (0.0,-1.0) == -1.0
3671 runString = "(0.0,-1.0)";
3672 if (-1.0f != jtt.bytecode.BC_fload_2.test(0.0f, -1.0f)) {
3673 fail(runString);
3674 return;
3675 }
3676 // (0.0,-1.01) == -1.01
3677 runString = "(0.0,-1.01)";
3678 if (-1.01f != jtt.bytecode.BC_fload_2.test(0.0f, -1.01f)) {
3679 fail(runString);
3680 return;
3681 }
3682 } catch (Throwable t) {
3683 fail(runString, t);
3684 return;
3685 }
3686 pass();
3687 }
3688
3689 static void jtt_bytecode_BC_fmul() {
3690 begin("jtt.bytecode.BC_fmul");
3691 String runString = null;
3692 try {
3693 // (311.0,10.0) == 3110.0
3694 runString = "(311.0,10.0)";
3695 if (3110.0f != jtt.bytecode.BC_fmul.test(311.0f, 10.0f)) {
3696 fail(runString);
3697 return;
3698 }
3699 } catch (Throwable t) {
3700 fail(runString, t);
3701 return;
3702 }
3703 pass();
3704 }
3705
3706 static void jtt_bytecode_BC_fneg() {
3707 begin("jtt.bytecode.BC_fneg");
3708 String runString = null;
3709 try {
3710 // (0.0) == -0.0
3711 runString = "(0.0)";
3712 if (-0.0f != jtt.bytecode.BC_fneg.test(0.0f)) {
3713 fail(runString);
3714 return;
3715 }
3716 // (-1.01) == 1.01
3717 runString = "(-1.01)";
3718 if (1.01f != jtt.bytecode.BC_fneg.test(-1.01f)) {
3719 fail(runString);
3720 return;
3721 }
3722 // (7263.8735) == -7263.8735
3723 runString = "(7263.8735)";
3724 if (-7263.8735f != jtt.bytecode.BC_fneg.test(7263.8735f)) {
3725 fail(runString);
3726 return;
3727 }
3728 } catch (Throwable t) {
3729 fail(runString, t);
3730 return;
3731 }
3732 pass();
3733 }
3734
3735 static void jtt_bytecode_BC_frem() {
3736 begin("jtt.bytecode.BC_frem");
3737 String runString = null;
3738 try {
3739 // (311.0,10.0) == 1.0
3740 runString = "(311.0,10.0)";
3741 if (1.0f != jtt.bytecode.BC_frem.test(311.0f, 10.0f)) {
3742 fail(runString);
3743 return;
3744 }
3745 // (12.5,6.0) == 0.5
3746 runString = "(12.5,6.0)";
3747 if (0.5f != jtt.bytecode.BC_frem.test(12.5f, 6.0f)) {
3748 fail(runString);
3749 return;
3750 }
3751 } catch (Throwable t) {
3752 fail(runString, t);
3753 return;
3754 }
3755 pass();
3756 }
3757
3758 static void jtt_bytecode_BC_freturn() {
3759 begin("jtt.bytecode.BC_freturn");
3760 String runString = null;
3761 try {
3762 // (0.0) == 0.0
3763 runString = "(0.0)";
3764 if (0.0f != jtt.bytecode.BC_freturn.test(0.0f)) {
3765 fail(runString);
3766 return;
3767 }
3768 // (1.1) == 1.1
3769 runString = "(1.1)";
3770 if (1.1f != jtt.bytecode.BC_freturn.test(1.1f)) {
3771 fail(runString);
3772 return;
3773 }
3774 // (-1.4) == -1.4
3775 runString = "(-1.4)";
3776 if (-1.4f != jtt.bytecode.BC_freturn.test(-1.4f)) {
3777 fail(runString);
3778 return;
3779 }
3780 // (256.33) == 256.33
3781 runString = "(256.33)";
3782 if (256.33f != jtt.bytecode.BC_freturn.test(256.33f)) {
3783 fail(runString);
3784 return;
3785 }
3786 // (1000.001) == 1000.001
3787 runString = "(1000.001)";
3788 if (1000.001f != jtt.bytecode.BC_freturn.test(1000.001f)) {
3789 fail(runString);
3790 return;
3791 }
3792 } catch (Throwable t) {
3793 fail(runString, t);
3794 return;
3795 }
3796 pass();
3797 }
3798
3799 static void jtt_bytecode_BC_fsub() {
3800 begin("jtt.bytecode.BC_fsub");
3801 String runString = null;
3802 try {
3803 // (0.0,0.0) == 0.0
3804 runString = "(0.0,0.0)";
3805 if (0.0f != jtt.bytecode.BC_fsub.test(0.0f, 0.0f)) {
3806 fail(runString);
3807 return;
3808 }
3809 // (1.0,1.0) == 0.0
3810 runString = "(1.0,1.0)";
3811 if (0.0f != jtt.bytecode.BC_fsub.test(1.0f, 1.0f)) {
3812 fail(runString);
3813 return;
3814 }
3815 // (253.11,54.43) == 198.68
3816 runString = "(253.11,54.43)";
3817 if (198.68f != jtt.bytecode.BC_fsub.test(253.11f, 54.43f)) {
3818 fail(runString);
3819 return;
3820 }
3821 } catch (Throwable t) {
3822 fail(runString, t);
3823 return;
3824 }
3825 pass();
3826 }
3827
3828 static void jtt_bytecode_BC_getfield() {
3829 begin("jtt.bytecode.BC_getfield");
3830 String runString = null;
3831 try {
3832 // (0) == 13
3833 runString = "(0)";
3834 if (13 != jtt.bytecode.BC_getfield.test(0)) {
3835 fail(runString);
3836 return;
3837 }
3838 } catch (Throwable t) {
3839 fail(runString, t);
3840 return;
3841 }
3842 pass();
3843 }
3844
3845 static void jtt_bytecode_BC_getstatic_b() {
3846 begin("jtt.bytecode.BC_getstatic_b");
3847 String runString = null;
3848 try {
3849 // (0) == 11
3850 runString = "(0)";
3851 if ((byte) 11 != jtt.bytecode.BC_getstatic_b.test(0)) {
3852 fail(runString);
3853 return;
3854 }
3855 // (1) == 11
3856 runString = "(1)";
3857 if ((byte) 11 != jtt.bytecode.BC_getstatic_b.test(1)) {
3858 fail(runString);
3859 return;
3860 }
3861 // (2) == 11
3862 runString = "(2)";
3863 if ((byte) 11 != jtt.bytecode.BC_getstatic_b.test(2)) {
3864 fail(runString);
3865 return;
3866 }
3867 } catch (Throwable t) {
3868 fail(runString, t);
3869 return;
3870 }
3871 pass();
3872 }
3873
3874 static void jtt_bytecode_BC_getstatic_c() {
3875 begin("jtt.bytecode.BC_getstatic_c");
3876 String runString = null;
3877 try {
3878 // (0) == '\13'
3879 runString = "(0)";
3880 if ((char) 11 != jtt.bytecode.BC_getstatic_c.test(0)) {
3881 fail(runString);
3882 return;
3883 }
3884 // (1) == '\13'
3885 runString = "(1)";
3886 if ((char) 11 != jtt.bytecode.BC_getstatic_c.test(1)) {
3887 fail(runString);
3888 return;
3889 }
3890 } catch (Throwable t) {
3891 fail(runString, t);
3892 return;
3893 }
3894 pass();
3895 }
3896
3897 static void jtt_bytecode_BC_getstatic_d() {
3898 begin("jtt.bytecode.BC_getstatic_d");
3899 String runString = null;
3900 try {
3901 // (0) == 11.0
3902 runString = "(0)";
3903 if (11.0 != jtt.bytecode.BC_getstatic_d.test(0)) {
3904 fail(runString);
3905 return;
3906 }
3907 // (1) == 11.0
3908 runString = "(1)";
3909 if (11.0 != jtt.bytecode.BC_getstatic_d.test(1)) {
3910 fail(runString);
3911 return;
3912 }
3913 } catch (Throwable t) {
3914 fail(runString, t);
3915 return;
3916 }
3917 pass();
3918 }
3919
3920 static void jtt_bytecode_BC_getstatic_f() {
3921 begin("jtt.bytecode.BC_getstatic_f");
3922 String runString = null;
3923 try {
3924 // (0) == 11.0
3925 runString = "(0)";
3926 if (11.0f != jtt.bytecode.BC_getstatic_f.test(0)) {
3927 fail(runString);
3928 return;
3929 }
3930 // (1) == 11.0
3931 runString = "(1)";
3932 if (11.0f != jtt.bytecode.BC_getstatic_f.test(1)) {
3933 fail(runString);
3934 return;
3935 }
3936 } catch (Throwable t) {
3937 fail(runString, t);
3938 return;
3939 }
3940 pass();
3941 }
3942
3943 static void jtt_bytecode_BC_getstatic_i() {
3944 begin("jtt.bytecode.BC_getstatic_i");
3945 String runString = null;
3946 try {
3947 // (0) == 11
3948 runString = "(0)";
3949 if (11 != jtt.bytecode.BC_getstatic_i.test(0)) {
3950 fail(runString);
3951 return;
3952 }
3953 // (1) == 11
3954 runString = "(1)";
3955 if (11 != jtt.bytecode.BC_getstatic_i.test(1)) {
3956 fail(runString);
3957 return;
3958 }
3959 // (2) == 11
3960 runString = "(2)";
3961 if (11 != jtt.bytecode.BC_getstatic_i.test(2)) {
3962 fail(runString);
3963 return;
3964 }
3965 // (3) == 11
3966 runString = "(3)";
3967 if (11 != jtt.bytecode.BC_getstatic_i.test(3)) {
3968 fail(runString);
3969 return;
3970 }
3971 // (-4) == 11
3972 runString = "(-4)";
3973 if (11 != jtt.bytecode.BC_getstatic_i.test(-4)) {
3974 fail(runString);
3975 return;
3976 }
3977 } catch (Throwable t) {
3978 fail(runString, t);
3979 return;
3980 }
3981 pass();
3982 }
3983
3984 static void jtt_bytecode_BC_getstatic_l() {
3985 begin("jtt.bytecode.BC_getstatic_l");
3986 String runString = null;
3987 try {
3988 // (0) == 11
3989 runString = "(0)";
3990 if (11L != jtt.bytecode.BC_getstatic_l.test(0)) {
3991 fail(runString);
3992 return;
3993 }
3994 // (1) == 11
3995 runString = "(1)";
3996 if (11L != jtt.bytecode.BC_getstatic_l.test(1)) {
3997 fail(runString);
3998 return;
3999 }
4000 } catch (Throwable t) {
4001 fail(runString, t);
4002 return;
4003 }
4004 pass();
4005 }
4006
4007 static void jtt_bytecode_BC_getstatic_s() {
4008 begin("jtt.bytecode.BC_getstatic_s");
4009 String runString = null;
4010 try {
4011 // (0) == 11
4012 runString = "(0)";
4013 if ((short) 11 != jtt.bytecode.BC_getstatic_s.test(0)) {
4014 fail(runString);
4015 return;
4016 }
4017 // (1) == 11
4018 runString = "(1)";
4019 if ((short) 11 != jtt.bytecode.BC_getstatic_s.test(1)) {
4020 fail(runString);
4021 return;
4022 }
4023 } catch (Throwable t) {
4024 fail(runString, t);
4025 return;
4026 }
4027 pass();
4028 }
4029
4030 static void jtt_bytecode_BC_getstatic_z() {
4031 begin("jtt.bytecode.BC_getstatic_z");
4032 String runString = null;
4033 try {
4034 // (0) == true
4035 runString = "(0)";
4036 if (true != jtt.bytecode.BC_getstatic_z.test(0)) {
4037 fail(runString);
4038 return;
4039 }
4040 // (1) == true
4041 runString = "(1)";
4042 if (true != jtt.bytecode.BC_getstatic_z.test(1)) {
4043 fail(runString);
4044 return;
4045 }
4046 } catch (Throwable t) {
4047 fail(runString, t);
4048 return;
4049 }
4050 pass();
4051 }
4052
4053 static void jtt_bytecode_BC_i2b() {
4054 begin("jtt.bytecode.BC_i2b");
4055 String runString = null;
4056 try {
4057 // (-1) == -1
4058 runString = "(-1)";
4059 if ((byte) -1 != jtt.bytecode.BC_i2b.test(-1)) {
4060 fail(runString);
4061 return;
4062 }
4063 // (2) == 2
4064 runString = "(2)";
4065 if ((byte) 2 != jtt.bytecode.BC_i2b.test(2)) {
4066 fail(runString);
4067 return;
4068 }
4069 // (255) == -1
4070 runString = "(255)";
4071 if ((byte) -1 != jtt.bytecode.BC_i2b.test(255)) {
4072 fail(runString);
4073 return;
4074 }
4075 // (128) == -128
4076 runString = "(128)";
4077 if ((byte) -128 != jtt.bytecode.BC_i2b.test(128)) {
4078 fail(runString);
4079 return;
4080 }
4081 } catch (Throwable t) {
4082 fail(runString, t);
4083 return;
4084 }
4085 pass();
4086 }
4087
4088 static void jtt_bytecode_BC_i2c() {
4089 begin("jtt.bytecode.BC_i2c");
4090 String runString = null;
4091 try {
4092 // (-1) == '\177777'
4093 runString = "(-1)";
4094 if ((char) 65535 != jtt.bytecode.BC_i2c.test(-1)) {
4095 fail(runString);
4096 return;
4097 }
4098 // (645) == '\1205'
4099 runString = "(645)";
4100 if ((char) 645 != jtt.bytecode.BC_i2c.test(645)) {
4101 fail(runString);
4102 return;
4103 }
4104 // (65535) == '\177777'
4105 runString = "(65535)";
4106 if ((char) 65535 != jtt.bytecode.BC_i2c.test(65535)) {
4107 fail(runString);
4108 return;
4109 }
4110 } catch (Throwable t) {
4111 fail(runString, t);
4112 return;
4113 }
4114 pass();
4115 }
4116
4117 static void jtt_bytecode_BC_i2d() {
4118 begin("jtt.bytecode.BC_i2d");
4119 String runString = null;
4120 try {
4121 // (0) == 0.0
4122 runString = "(0)";
4123 if (0.0 != jtt.bytecode.BC_i2d.test(0)) {
4124 fail(runString);
4125 return;
4126 }
4127 // (1) == 1.0
4128 runString = "(1)";
4129 if (1.0 != jtt.bytecode.BC_i2d.test(1)) {
4130 fail(runString);
4131 return;
4132 }
4133 // (-34) == -34.0
4134 runString = "(-34)";
4135 if (-34.0 != jtt.bytecode.BC_i2d.test(-34)) {
4136 fail(runString);
4137 return;
4138 }
4139 } catch (Throwable t) {
4140 fail(runString, t);
4141 return;
4142 }
4143 pass();
4144 }
4145
4146 static void jtt_bytecode_BC_i2f() {
4147 begin("jtt.bytecode.BC_i2f");
4148 String runString = null;
4149 try {
4150 // (0) == 0.0
4151 runString = "(0)";
4152 if (0.0f != jtt.bytecode.BC_i2f.test(0)) {
4153 fail(runString);
4154 return;
4155 }
4156 // (1) == 1.0
4157 runString = "(1)";
4158 if (1.0f != jtt.bytecode.BC_i2f.test(1)) {
4159 fail(runString);
4160 return;
4161 }
4162 // (-34) == -34.0
4163 runString = "(-34)";
4164 if (-34.0f != jtt.bytecode.BC_i2f.test(-34)) {
4165 fail(runString);
4166 return;
4167 }
4168 } catch (Throwable t) {
4169 fail(runString, t);
4170 return;
4171 }
4172 pass();
4173 }
4174
4175 static void jtt_bytecode_BC_i2l() {
4176 begin("jtt.bytecode.BC_i2l");
4177 String runString = null;
4178 try {
4179 // (1) == 1
4180 runString = "(1)";
4181 if (1L != jtt.bytecode.BC_i2l.test(1)) {
4182 fail(runString);
4183 return;
4184 }
4185 // (2) == 2
4186 runString = "(2)";
4187 if (2L != jtt.bytecode.BC_i2l.test(2)) {
4188 fail(runString);
4189 return;
4190 }
4191 // (3) == 3
4192 runString = "(3)";
4193 if (3L != jtt.bytecode.BC_i2l.test(3)) {
4194 fail(runString);
4195 return;
4196 }
4197 // (-1) == -1
4198 runString = "(-1)";
4199 if (-1L != jtt.bytecode.BC_i2l.test(-1)) {
4200 fail(runString);
4201 return;
4202 }
4203 // (-2147483647) == -2147483647
4204 runString = "(-2147483647)";
4205 if (-2147483647L != jtt.bytecode.BC_i2l.test(-2147483647)) {
4206 fail(runString);
4207 return;
4208 }
4209 // (-2147483648) == -2147483648
4210 runString = "(-2147483648)";
4211 if (-2147483648L != jtt.bytecode.BC_i2l.test(-2147483648)) {
4212 fail(runString);
4213 return;
4214 }
4215 // (2147483647) == 2147483647
4216 runString = "(2147483647)";
4217 if (2147483647L != jtt.bytecode.BC_i2l.test(2147483647)) {
4218 fail(runString);
4219 return;
4220 }
4221 } catch (Throwable t) {
4222 fail(runString, t);
4223 return;
4224 }
4225 pass();
4226 }
4227
4228 static void jtt_bytecode_BC_i2s() {
4229 begin("jtt.bytecode.BC_i2s");
4230 String runString = null;
4231 try {
4232 // (-1) == -1
4233 runString = "(-1)";
4234 if ((short) -1 != jtt.bytecode.BC_i2s.test(-1)) {
4235 fail(runString);
4236 return;
4237 }
4238 // (34) == 34
4239 runString = "(34)";
4240 if ((short) 34 != jtt.bytecode.BC_i2s.test(34)) {
4241 fail(runString);
4242 return;
4243 }
4244 // (65535) == -1
4245 runString = "(65535)";
4246 if ((short) -1 != jtt.bytecode.BC_i2s.test(65535)) {
4247 fail(runString);
4248 return;
4249 }
4250 // (32768) == -32768
4251 runString = "(32768)";
4252 if ((short) -32768 != jtt.bytecode.BC_i2s.test(32768)) {
4253 fail(runString);
4254 return;
4255 }
4256 } catch (Throwable t) {
4257 fail(runString, t);
4258 return;
4259 }
4260 pass();
4261 }
4262
4263 static void jtt_bytecode_BC_iadd() {
4264 begin("jtt.bytecode.BC_iadd");
4265 String runString = null;
4266 try {
4267 // (1,2) == 3
4268 runString = "(1,2)";
4269 if (3 != jtt.bytecode.BC_iadd.test(1, 2)) {
4270 fail(runString);
4271 return;
4272 }
4273 // (0,-1) == -1
4274 runString = "(0,-1)";
4275 if (-1 != jtt.bytecode.BC_iadd.test(0, -1)) {
4276 fail(runString);
4277 return;
4278 }
4279 // (33,67) == 100
4280 runString = "(33,67)";
4281 if (100 != jtt.bytecode.BC_iadd.test(33, 67)) {
4282 fail(runString);
4283 return;
4284 }
4285 // (1,-1) == 0
4286 runString = "(1,-1)";
4287 if (0 != jtt.bytecode.BC_iadd.test(1, -1)) {
4288 fail(runString);
4289 return;
4290 }
4291 // (-2147483648,1) == -2147483647
4292 runString = "(-2147483648,1)";
4293 if (-2147483647 != jtt.bytecode.BC_iadd.test(-2147483648, 1)) {
4294 fail(runString);
4295 return;
4296 }
4297 // (2147483647,1) == -2147483648
4298 runString = "(2147483647,1)";
4299 if (-2147483648 != jtt.bytecode.BC_iadd.test(2147483647, 1)) {
4300 fail(runString);
4301 return;
4302 }
4303 // (-2147483647,-2) == 2147483647
4304 runString = "(-2147483647,-2)";
4305 if (2147483647 != jtt.bytecode.BC_iadd.test(-2147483647, -2)) {
4306 fail(runString);
4307 return;
4308 }
4309 } catch (Throwable t) {
4310 fail(runString, t);
4311 return;
4312 }
4313 pass();
4314 }
4315
4316 static void jtt_bytecode_BC_iadd2() {
4317 begin("jtt.bytecode.BC_iadd2");
4318 String runString = null;
4319 try {
4320 // (1,2) == 3
4321 runString = "(1,2)";
4322 if (3 != jtt.bytecode.BC_iadd2.test((byte) 1, (byte) 2)) {
4323 fail(runString);
4324 return;
4325 }
4326 // (0,-1) == -1
4327 runString = "(0,-1)";
4328 if (-1 != jtt.bytecode.BC_iadd2.test((byte) 0, (byte) -1)) {
4329 fail(runString);
4330 return;
4331 }
4332 // (33,67) == 100
4333 runString = "(33,67)";
4334 if (100 != jtt.bytecode.BC_iadd2.test((byte) 33, (byte) 67)) {
4335 fail(runString);
4336 return;
4337 }
4338 // (1,-1) == 0
4339 runString = "(1,-1)";
4340 if (0 != jtt.bytecode.BC_iadd2.test((byte) 1, (byte) -1)) {
4341 fail(runString);
4342 return;
4343 }
4344 // (-128,1) == -127
4345 runString = "(-128,1)";
4346 if (-127 != jtt.bytecode.BC_iadd2.test((byte) -128, (byte) 1)) {
4347 fail(runString);
4348 return;
4349 }
4350 // (127,1) == 128
4351 runString = "(127,1)";
4352 if (128 != jtt.bytecode.BC_iadd2.test((byte) 127, (byte) 1)) {
4353 fail(runString);
4354 return;
4355 }
4356 } catch (Throwable t) {
4357 fail(runString, t);
4358 return;
4359 }
4360 pass();
4361 }
4362
4363 static void jtt_bytecode_BC_iadd3() {
4364 begin("jtt.bytecode.BC_iadd3");
4365 String runString = null;
4366 try {
4367 // (1,2) == 3
4368 runString = "(1,2)";
4369 if (3 != jtt.bytecode.BC_iadd3.test((short) 1, (short) 2)) {
4370 fail(runString);
4371 return;
4372 }
4373 // (0,-1) == -1
4374 runString = "(0,-1)";
4375 if (-1 != jtt.bytecode.BC_iadd3.test((short) 0, (short) -1)) {
4376 fail(runString);
4377 return;
4378 }
4379 // (33,67) == 100
4380 runString = "(33,67)";
4381 if (100 != jtt.bytecode.BC_iadd3.test((short) 33, (short) 67)) {
4382 fail(runString);
4383 return;
4384 }
4385 // (1,-1) == 0
4386 runString = "(1,-1)";
4387 if (0 != jtt.bytecode.BC_iadd3.test((short) 1, (short) -1)) {
4388 fail(runString);
4389 return;
4390 }
4391 // (-128,1) == -127
4392 runString = "(-128,1)";
4393 if (-127 != jtt.bytecode.BC_iadd3.test((short) -128, (short) 1)) {
4394 fail(runString);
4395 return;
4396 }
4397 // (127,1) == 128
4398 runString = "(127,1)";
4399 if (128 != jtt.bytecode.BC_iadd3.test((short) 127, (short) 1)) {
4400 fail(runString);
4401 return;
4402 }
4403 // (-32768,1) == -32767
4404 runString = "(-32768,1)";
4405 if (-32767 != jtt.bytecode.BC_iadd3.test((short) -32768, (short) 1)) {
4406 fail(runString);
4407 return;
4408 }
4409 // (32767,1) == 32768
4410 runString = "(32767,1)";
4411 if (32768 != jtt.bytecode.BC_iadd3.test((short) 32767, (short) 1)) {
4412 fail(runString);
4413 return;
4414 }
4415 } catch (Throwable t) {
4416 fail(runString, t);
4417 return;
4418 }
4419 pass();
4420 }
4421
4422 static void jtt_bytecode_BC_iaload() {
4423 begin("jtt.bytecode.BC_iaload");
4424 String runString = null;
4425 try {
4426 // (0) == 0
4427 runString = "(0)";
4428 if (0 != jtt.bytecode.BC_iaload.test(0)) {
4429 fail(runString);
4430 return;
4431 }
4432 // (1) == -1
4433 runString = "(1)";
4434 if (-1 != jtt.bytecode.BC_iaload.test(1)) {
4435 fail(runString);
4436 return;
4437 }
4438 // (2) == 4
4439 runString = "(2)";
4440 if (4 != jtt.bytecode.BC_iaload.test(2)) {
4441 fail(runString);
4442 return;
4443 }
4444 // (3) == 1000000000
4445 runString = "(3)";
4446 if (1000000000 != jtt.bytecode.BC_iaload.test(3)) {
4447 fail(runString);
4448 return;
4449 }
4450 } catch (Throwable t) {
4451 fail(runString, t);
4452 return;
4453 }
4454 pass();
4455 }
4456
4457 static void jtt_bytecode_BC_iand() {
4458 begin("jtt.bytecode.BC_iand");
4459 String runString = null;
4460 try {
4461 // (1,2) == 0
4462 runString = "(1,2)";
4463 if (0 != jtt.bytecode.BC_iand.test(1, 2)) {
4464 fail(runString);
4465 return;
4466 }
4467 // (0,-1) == 0
4468 runString = "(0,-1)";
4469 if (0 != jtt.bytecode.BC_iand.test(0, -1)) {
4470 fail(runString);
4471 return;
4472 }
4473 // (31,63) == 31
4474 runString = "(31,63)";
4475 if (31 != jtt.bytecode.BC_iand.test(31, 63)) {
4476 fail(runString);
4477 return;
4478 }
4479 // (6,4) == 4
4480 runString = "(6,4)";
4481 if (4 != jtt.bytecode.BC_iand.test(6, 4)) {
4482 fail(runString);
4483 return;
4484 }
4485 // (-2147483648,1) == 0
4486 runString = "(-2147483648,1)";
4487 if (0 != jtt.bytecode.BC_iand.test(-2147483648, 1)) {
4488 fail(runString);
4489 return;
4490 }
4491 } catch (Throwable t) {
4492 fail(runString, t);
4493 return;
4494 }
4495 pass();
4496 }
4497
4498 static void jtt_bytecode_BC_iastore() {
4499 begin("jtt.bytecode.BC_iastore");
4500 String runString = null;
4501 try {
4502 // (0,0) == 0
4503 runString = "(0,0)";
4504 if (0 != jtt.bytecode.BC_iastore.test(0, 0)) {
4505 fail(runString);
4506 return;
4507 }
4508 // (1,-1) == -1
4509 runString = "(1,-1)";
4510 if (-1 != jtt.bytecode.BC_iastore.test(1, -1)) {
4511 fail(runString);
4512 return;
4513 }
4514 // (2,11) == 11
4515 runString = "(2,11)";
4516 if (11 != jtt.bytecode.BC_iastore.test(2, 11)) {
4517 fail(runString);
4518 return;
4519 }
4520 // (3,-14) == -14
4521 runString = "(3,-14)";
4522 if (-14 != jtt.bytecode.BC_iastore.test(3, -14)) {
4523 fail(runString);
4524 return;
4525 }
4526 } catch (Throwable t) {
4527 fail(runString, t);
4528 return;
4529 }
4530 pass();
4531 }
4532
4533 static void jtt_bytecode_BC_iconst() {
4534 begin("jtt.bytecode.BC_iconst");
4535 String runString = null;
4536 try {
4537 // (0) == 0
4538 runString = "(0)";
4539 if (0 != jtt.bytecode.BC_iconst.test(0)) {
4540 fail(runString);
4541 return;
4542 }
4543 // (1) == 1
4544 runString = "(1)";
4545 if (1 != jtt.bytecode.BC_iconst.test(1)) {
4546 fail(runString);
4547 return;
4548 }
4549 // (2) == 2
4550 runString = "(2)";
4551 if (2 != jtt.bytecode.BC_iconst.test(2)) {
4552 fail(runString);
4553 return;
4554 }
4555 // (3) == 3
4556 runString = "(3)";
4557 if (3 != jtt.bytecode.BC_iconst.test(3)) {
4558 fail(runString);
4559 return;
4560 }
4561 // (4) == 4
4562 runString = "(4)";
4563 if (4 != jtt.bytecode.BC_iconst.test(4)) {
4564 fail(runString);
4565 return;
4566 }
4567 // (5) == 5
4568 runString = "(5)";
4569 if (5 != jtt.bytecode.BC_iconst.test(5)) {
4570 fail(runString);
4571 return;
4572 }
4573 // (6) == 375
4574 runString = "(6)";
4575 if (375 != jtt.bytecode.BC_iconst.test(6)) {
4576 fail(runString);
4577 return;
4578 }
4579 } catch (Throwable t) {
4580 fail(runString, t);
4581 return;
4582 }
4583 pass();
4584 }
4585
4586 static void jtt_bytecode_BC_idiv() {
4587 begin("jtt.bytecode.BC_idiv");
4588 String runString = null;
4589 try {
4590 // (1,2) == 0
4591 runString = "(1,2)";
4592 if (0 != jtt.bytecode.BC_idiv.test(1, 2)) {
4593 fail(runString);
4594 return;
4595 }
4596 // (2,-1) == -2
4597 runString = "(2,-1)";
4598 if (-2 != jtt.bytecode.BC_idiv.test(2, -1)) {
4599 fail(runString);
4600 return;
4601 }
4602 // (256,4) == 64
4603 runString = "(256,4)";
4604 if (64 != jtt.bytecode.BC_idiv.test(256, 4)) {
4605 fail(runString);
4606 return;
4607 }
4608 // (135,7) == 19
4609 runString = "(135,7)";
4610 if (19 != jtt.bytecode.BC_idiv.test(135, 7)) {
4611 fail(runString);
4612 return;
4613 }
4614 } catch (Throwable t) {
4615 fail(runString, t);
4616 return;
4617 }
4618 pass();
4619 }
4620
4621 static void jtt_bytecode_BC_idiv2() {
4622 begin("jtt.bytecode.BC_idiv2");
4623 String runString = null;
4624 try {
4625 // (-2147483648,-1) == -2147483648
4626 runString = "(-2147483648,-1)";
4627 if (-2147483648 != jtt.bytecode.BC_idiv2.test(-2147483648, -1)) {
4628 fail(runString);
4629 return;
4630 }
4631 // (-2147483648,1) == -2147483648
4632 runString = "(-2147483648,1)";
4633 if (-2147483648 != jtt.bytecode.BC_idiv2.test(-2147483648, 1)) {
4634 fail(runString);
4635 return;
4636 }
4637 } catch (Throwable t) {
4638 fail(runString, t);
4639 return;
4640 }
4641 pass();
4642 }
4643
4644 static void jtt_bytecode_BC_ifeq() {
4645 begin("jtt.bytecode.BC_ifeq");
4646 String runString = null;
4647 try {
4648 // (0) == 2
4649 runString = "(0)";
4650 if (2 != jtt.bytecode.BC_ifeq.test(0)) {
4651 fail(runString);
4652 return;
4653 }
4654 // (1) == -2
4655 runString = "(1)";
4656 if (-2 != jtt.bytecode.BC_ifeq.test(1)) {
4657 fail(runString);
4658 return;
4659 }
4660 } catch (Throwable t) {
4661 fail(runString, t);
4662 return;
4663 }
4664 pass();
4665 }
4666
4667 static void jtt_bytecode_BC_ifeq_2() {
4668 begin("jtt.bytecode.BC_ifeq_2");
4669 String runString = null;
4670 try {
4671 // (0) == true
4672 runString = "(0)";
4673 if (true != jtt.bytecode.BC_ifeq_2.test(0)) {
4674 fail(runString);
4675 return;
4676 }
4677 // (1) == false
4678 runString = "(1)";
4679 if (false != jtt.bytecode.BC_ifeq_2.test(1)) {
4680 fail(runString);
4681 return;
4682 }
4683 } catch (Throwable t) {
4684 fail(runString, t);
4685 return;
4686 }
4687 pass();
4688 }
4689
4690 static void jtt_bytecode_BC_ifeq_3() {
4691 begin("jtt.bytecode.BC_ifeq_3");
4692 String runString = null;
4693 try {
4694 // (0) == false
4695 runString = "(0)";
4696 if (false != jtt.bytecode.BC_ifeq_3.test(0)) {
4697 fail(runString);
4698 return;
4699 }
4700 // (1) == true
4701 runString = "(1)";
4702 if (true != jtt.bytecode.BC_ifeq_3.test(1)) {
4703 fail(runString);
4704 return;
4705 }
4706 } catch (Throwable t) {
4707 fail(runString, t);
4708 return;
4709 }
4710 pass();
4711 }
4712
4713 static void jtt_bytecode_BC_ifge() {
4714 begin("jtt.bytecode.BC_ifge");
4715 String runString = null;
4716 try {
4717 // (0) == 2
4718 runString = "(0)";
4719 if (2 != jtt.bytecode.BC_ifge.test(0)) {
4720 fail(runString);
4721 return;
4722 }
4723 // (1) == 2
4724 runString = "(1)";
4725 if (2 != jtt.bytecode.BC_ifge.test(1)) {
4726 fail(runString);
4727 return;
4728 }
4729 } catch (Throwable t) {
4730 fail(runString, t);
4731 return;
4732 }
4733 pass();
4734 }
4735
4736 static void jtt_bytecode_BC_ifge_2() {
4737 begin("jtt.bytecode.BC_ifge_2");
4738 String runString = null;
4739 try {
4740 // (0,1) == false
4741 runString = "(0,1)";
4742 if (false != jtt.bytecode.BC_ifge_2.test(0, 1)) {
4743 fail(runString);
4744 return;
4745 }
4746 // (1,0) == true
4747 runString = "(1,0)";
4748 if (true != jtt.bytecode.BC_ifge_2.test(1, 0)) {
4749 fail(runString);
4750 return;
4751 }
4752 // (1,1) == true
4753 runString = "(1,1)";
4754 if (true != jtt.bytecode.BC_ifge_2.test(1, 1)) {
4755 fail(runString);
4756 return;
4757 }
4758 // (0,-100) == true
4759 runString = "(0,-100)";
4760 if (true != jtt.bytecode.BC_ifge_2.test(0, -100)) {
4761 fail(runString);
4762 return;
4763 }
4764 // (-1,0) == false
4765 runString = "(-1,0)";
4766 if (false != jtt.bytecode.BC_ifge_2.test(-1, 0)) {
4767 fail(runString);
4768 return;
4769 }
4770 // (-12,-12) == true
4771 runString = "(-12,-12)";
4772 if (true != jtt.bytecode.BC_ifge_2.test(-12, -12)) {
4773 fail(runString);
4774 return;
4775 }
4776 } catch (Throwable t) {
4777 fail(runString, t);
4778 return;
4779 }
4780 pass();
4781 }
4782
4783 static void jtt_bytecode_BC_ifge_3() {
4784 begin("jtt.bytecode.BC_ifge_3");
4785 String runString = null;
4786 try {
4787 // (0,1) == true
4788 runString = "(0,1)";
4789 if (true != jtt.bytecode.BC_ifge_3.test(0, 1)) {
4790 fail(runString);
4791 return;
4792 }
4793 // (1,0) == false
4794 runString = "(1,0)";
4795 if (false != jtt.bytecode.BC_ifge_3.test(1, 0)) {
4796 fail(runString);
4797 return;
4798 }
4799 // (1,1) == false
4800 runString = "(1,1)";
4801 if (false != jtt.bytecode.BC_ifge_3.test(1, 1)) {
4802 fail(runString);
4803 return;
4804 }
4805 // (0,-100) == false
4806 runString = "(0,-100)";
4807 if (false != jtt.bytecode.BC_ifge_3.test(0, -100)) {
4808 fail(runString);
4809 return;
4810 }
4811 // (-1,0) == true
4812 runString = "(-1,0)";
4813 if (true != jtt.bytecode.BC_ifge_3.test(-1, 0)) {
4814 fail(runString);
4815 return;
4816 }
4817 // (-12,-12) == false
4818 runString = "(-12,-12)";
4819 if (false != jtt.bytecode.BC_ifge_3.test(-12, -12)) {
4820 fail(runString);
4821 return;
4822 }
4823 } catch (Throwable t) {
4824 fail(runString, t);
4825 return;
4826 }
4827 pass();
4828 }
4829
4830 static void jtt_bytecode_BC_ifgt() {
4831 begin("jtt.bytecode.BC_ifgt");
4832 String runString = null;
4833 try {
4834 // (0) == -2
4835 runString = "(0)";
4836 if (-2 != jtt.bytecode.BC_ifgt.test(0)) {
4837 fail(runString);
4838 return;
4839 }
4840 // (1) == 2
4841 runString = "(1)";
4842 if (2 != jtt.bytecode.BC_ifgt.test(1)) {
4843 fail(runString);
4844 return;
4845 }
4846 } catch (Throwable t) {
4847 fail(runString, t);
4848 return;
4849 }
4850 pass();
4851 }
4852
4853 static void jtt_bytecode_BC_ificmplt1() {
4854 begin("jtt.bytecode.BC_ificmplt1");
4855 String runString = null;
4856 try {
4857 // (0) == 12
4858 runString = "(0)";
4859 if (12 != jtt.bytecode.BC_ificmplt1.test(0)) {
4860 fail(runString);
4861 return;
4862 }
4863 // (1) == 13
4864 runString = "(1)";
4865 if (13 != jtt.bytecode.BC_ificmplt1.test(1)) {
4866 fail(runString);
4867 return;
4868 }
4869 // (2) == 13
4870 runString = "(2)";
4871 if (13 != jtt.bytecode.BC_ificmplt1.test(2)) {
4872 fail(runString);
4873 return;
4874 }
4875 } catch (Throwable t) {
4876 fail(runString, t);
4877 return;
4878 }
4879 pass();
4880 }
4881
4882 static void jtt_bytecode_BC_ificmplt2() {
4883 begin("jtt.bytecode.BC_ificmplt2");
4884 String runString = null;
4885 try {
4886 // (0) == 12
4887 runString = "(0)";
4888 if (12 != jtt.bytecode.BC_ificmplt2.test(0)) {
4889 fail(runString);
4890 return;
4891 }
4892 // (1) == 12
4893 runString = "(1)";
4894 if (12 != jtt.bytecode.BC_ificmplt2.test(1)) {
4895 fail(runString);
4896 return;
4897 }
4898 // (2) == 13
4899 runString = "(2)";
4900 if (13 != jtt.bytecode.BC_ificmplt2.test(2)) {
4901 fail(runString);
4902 return;
4903 }
4904 } catch (Throwable t) {
4905 fail(runString, t);
4906 return;
4907 }
4908 pass();
4909 }
4910
4911 static void jtt_bytecode_BC_ificmpne1() {
4912 begin("jtt.bytecode.BC_ificmpne1");
4913 String runString = null;
4914 try {
4915 // (0) == 13
4916 runString = "(0)";
4917 if (13 != jtt.bytecode.BC_ificmpne1.test(0)) {
4918 fail(runString);
4919 return;
4920 }
4921 // (1) == 12
4922 runString = "(1)";
4923 if (12 != jtt.bytecode.BC_ificmpne1.test(1)) {
4924 fail(runString);
4925 return;
4926 }
4927 // (2) == 13
4928 runString = "(2)";
4929 if (13 != jtt.bytecode.BC_ificmpne1.test(2)) {
4930 fail(runString);
4931 return;
4932 }
4933 } catch (Throwable t) {
4934 fail(runString, t);
4935 return;
4936 }
4937 pass();
4938 }
4939
4940 static void jtt_bytecode_BC_ificmpne2() {
4941 begin("jtt.bytecode.BC_ificmpne2");
4942 String runString = null;
4943 try {
4944 // (0) == 13
4945 runString = "(0)";
4946 if (13 != jtt.bytecode.BC_ificmpne2.test(0)) {
4947 fail(runString);
4948 return;
4949 }
4950 // (1) == 12
4951 runString = "(1)";
4952 if (12 != jtt.bytecode.BC_ificmpne2.test(1)) {
4953 fail(runString);
4954 return;
4955 }
4956 // (2) == 13
4957 runString = "(2)";
4958 if (13 != jtt.bytecode.BC_ificmpne2.test(2)) {
4959 fail(runString);
4960 return;
4961 }
4962 } catch (Throwable t) {
4963 fail(runString, t);
4964 return;
4965 }
4966 pass();
4967 }
4968
4969 static void jtt_bytecode_BC_ifle() {
4970 begin("jtt.bytecode.BC_ifle");
4971 String runString = null;
4972 try {
4973 // (0) == 2
4974 runString = "(0)";
4975 if (2 != jtt.bytecode.BC_ifle.test(0)) {
4976 fail(runString);
4977 return;
4978 }
4979 // (1) == -2
4980 runString = "(1)";
4981 if (-2 != jtt.bytecode.BC_ifle.test(1)) {
4982 fail(runString);
4983 return;
4984 }
4985 } catch (Throwable t) {
4986 fail(runString, t);
4987 return;
4988 }
4989 pass();
4990 }
4991
4992 static void jtt_bytecode_BC_iflt() {
4993 begin("jtt.bytecode.BC_iflt");
4994 String runString = null;
4995 try {
4996 // (0) == -2
4997 runString = "(0)";
4998 if (-2 != jtt.bytecode.BC_iflt.test(0)) {
4999 fail(runString);
5000 return;
5001 }
5002 // (1) == -2
5003 runString = "(1)";
5004 if (-2 != jtt.bytecode.BC_iflt.test(1)) {
5005 fail(runString);
5006 return;
5007 }
5008 // (-1) == 2
5009 runString = "(-1)";
5010 if (2 != jtt.bytecode.BC_iflt.test(-1)) {
5011 fail(runString);
5012 return;
5013 }
5014 } catch (Throwable t) {
5015 fail(runString, t);
5016 return;
5017 }
5018 pass();
5019 }
5020
5021 static void jtt_bytecode_BC_ifne() {
5022 begin("jtt.bytecode.BC_ifne");
5023 String runString = null;
5024 try {
5025 // (0) == -2
5026 runString = "(0)";
5027 if (-2 != jtt.bytecode.BC_ifne.test(0)) {
5028 fail(runString);
5029 return;
5030 }
5031 // (1) == 2
5032 runString = "(1)";
5033 if (2 != jtt.bytecode.BC_ifne.test(1)) {
5034 fail(runString);
5035 return;
5036 }
5037 } catch (Throwable t) {
5038 fail(runString, t);
5039 return;
5040 }
5041 pass();
5042 }
5043
5044 static void jtt_bytecode_BC_ifnonnull() {
5045 begin("jtt.bytecode.BC_ifnonnull");
5046 String runString = null;
5047 try {
5048 // (null) == 2
5049 runString = "(null)";
5050 if (2 != jtt.bytecode.BC_ifnonnull.test(null)) {
5051 fail(runString);
5052 return;
5053 }
5054 // ("") == -2
5055 runString = "(\"\")";
5056 if (-2 != jtt.bytecode.BC_ifnonnull.test("")) {
5057 fail(runString);
5058 return;
5059 }
5060 } catch (Throwable t) {
5061 fail(runString, t);
5062 return;
5063 }
5064 pass();
5065 }
5066
5067 static void jtt_bytecode_BC_ifnonnull_2() {
5068 begin("jtt.bytecode.BC_ifnonnull_2");
5069 String runString = null;
5070 try {
5071 // (null) == false
5072 runString = "(null)";
5073 if (false != jtt.bytecode.BC_ifnonnull_2.test(null)) {
5074 fail(runString);
5075 return;
5076 }
5077 // ("") == true
5078 runString = "(\"\")";
5079 if (true != jtt.bytecode.BC_ifnonnull_2.test("")) {
5080 fail(runString);
5081 return;
5082 }
5083 } catch (Throwable t) {
5084 fail(runString, t);
5085 return;
5086 }
5087 pass();
5088 }
5089
5090 static void jtt_bytecode_BC_ifnonnull_3() {
5091 begin("jtt.bytecode.BC_ifnonnull_3");
5092 String runString = null;
5093 try {
5094 // (null) == 2
5095 runString = "(null)";
5096 if (2 != jtt.bytecode.BC_ifnonnull_3.test(null)) {
5097 fail(runString);
5098 return;
5099 }
5100 // ("") == 1
5101 runString = "(\"\")";
5102 if (1 != jtt.bytecode.BC_ifnonnull_3.test("")) {
5103 fail(runString);
5104 return;
5105 }
5106 } catch (Throwable t) {
5107 fail(runString, t);
5108 return;
5109 }
5110 pass();
5111 }
5112
5113 static void jtt_bytecode_BC_ifnull() {
5114 begin("jtt.bytecode.BC_ifnull");
5115 String runString = null;
5116 try {
5117 // (null) == -2
5118 runString = "(null)";
5119 if (-2 != jtt.bytecode.BC_ifnull.test(null)) {
5120 fail(runString);
5121 return;
5122 }
5123 // ("") == 2
5124 runString = "(\"\")";
5125 if (2 != jtt.bytecode.BC_ifnull.test("")) {
5126 fail(runString);
5127 return;
5128 }
5129 } catch (Throwable t) {
5130 fail(runString, t);
5131 return;
5132 }
5133 pass();
5134 }
5135
5136 static void jtt_bytecode_BC_ifnull_2() {
5137 begin("jtt.bytecode.BC_ifnull_2");
5138 String runString = null;
5139 try {
5140 // (null) == true
5141 runString = "(null)";
5142 if (true != jtt.bytecode.BC_ifnull_2.test(null)) {
5143 fail(runString);
5144 return;
5145 }
5146 // ("") == false
5147 runString = "(\"\")";
5148 if (false != jtt.bytecode.BC_ifnull_2.test("")) {
5149 fail(runString);
5150 return;
5151 }
5152 } catch (Throwable t) {
5153 fail(runString, t);
5154 return;
5155 }
5156 pass();
5157 }
5158
5159 static void jtt_bytecode_BC_ifnull_3() {
5160 begin("jtt.bytecode.BC_ifnull_3");
5161 String runString = null;
5162 try {
5163 // (null) == 1
5164 runString = "(null)";
5165 if (1 != jtt.bytecode.BC_ifnull_3.test(null)) {
5166 fail(runString);
5167 return;
5168 }
5169 // ("") == 2
5170 runString = "(\"\")";
5171 if (2 != jtt.bytecode.BC_ifnull_3.test("")) {
5172 fail(runString);
5173 return;
5174 }
5175 } catch (Throwable t) {
5176 fail(runString, t);
5177 return;
5178 }
5179 pass();
5180 }
5181
5182 static void jtt_bytecode_BC_iinc_1() {
5183 begin("jtt.bytecode.BC_iinc_1");
5184 String runString = null;
5185 try {
5186 // (1) == 2
5187 runString = "(1)";
5188 if (2 != jtt.bytecode.BC_iinc_1.test(1)) {
5189 fail(runString);
5190 return;
5191 }
5192 // (2) == 3
5193 runString = "(2)";
5194 if (3 != jtt.bytecode.BC_iinc_1.test(2)) {
5195 fail(runString);
5196 return;
5197 }
5198 // (4) == 5
5199 runString = "(4)";
5200 if (5 != jtt.bytecode.BC_iinc_1.test(4)) {
5201 fail(runString);
5202 return;
5203 }
5204 // (-1) == 0
5205 runString = "(-1)";
5206 if (0 != jtt.bytecode.BC_iinc_1.test(-1)) {
5207 fail(runString);
5208 return;
5209 }
5210 } catch (Throwable t) {
5211 fail(runString, t);
5212 return;
5213 }
5214 pass();
5215 }
5216
5217 static void jtt_bytecode_BC_iinc_2() {
5218 begin("jtt.bytecode.BC_iinc_2");
5219 String runString = null;
5220 try {
5221 // (1) == 3
5222 runString = "(1)";
5223 if (3 != jtt.bytecode.BC_iinc_2.test(1)) {
5224 fail(runString);
5225 return;
5226 }
5227 // (2) == 4
5228 runString = "(2)";
5229 if (4 != jtt.bytecode.BC_iinc_2.test(2)) {
5230 fail(runString);
5231 return;
5232 }
5233 // (4) == 6
5234 runString = "(4)";
5235 if (6 != jtt.bytecode.BC_iinc_2.test(4)) {
5236 fail(runString);
5237 return;
5238 }
5239 // (-2) == 0
5240 runString = "(-2)";
5241 if (0 != jtt.bytecode.BC_iinc_2.test(-2)) {
5242 fail(runString);
5243 return;
5244 }
5245 } catch (Throwable t) {
5246 fail(runString, t);
5247 return;
5248 }
5249 pass();
5250 }
5251
5252 static void jtt_bytecode_BC_iinc_3() {
5253 begin("jtt.bytecode.BC_iinc_3");
5254 String runString = null;
5255 try {
5256 // (1) == 52
5257 runString = "(1)";
5258 if (52 != jtt.bytecode.BC_iinc_3.test(1)) {
5259 fail(runString);
5260 return;
5261 }
5262 // (2) == 53
5263 runString = "(2)";
5264 if (53 != jtt.bytecode.BC_iinc_3.test(2)) {
5265 fail(runString);
5266 return;
5267 }
5268 // (4) == 55
5269 runString = "(4)";
5270 if (55 != jtt.bytecode.BC_iinc_3.test(4)) {
5271 fail(runString);
5272 return;
5273 }
5274 // (-1) == 50
5275 runString = "(-1)";
5276 if (50 != jtt.bytecode.BC_iinc_3.test(-1)) {
5277 fail(runString);
5278 return;
5279 }
5280 } catch (Throwable t) {
5281 fail(runString, t);
5282 return;
5283 }
5284 pass();
5285 }
5286
5287 static void jtt_bytecode_BC_iinc_4() {
5288 begin("jtt.bytecode.BC_iinc_4");
5289 String runString = null;
5290 try {
5291 // (1) == 513
5292 runString = "(1)";
5293 if (513 != jtt.bytecode.BC_iinc_4.test(1)) {
5294 fail(runString);
5295 return;
5296 }
5297 // (2) == 514
5298 runString = "(2)";
5299 if (514 != jtt.bytecode.BC_iinc_4.test(2)) {
5300 fail(runString);
5301 return;
5302 }
5303 // (4) == 516
5304 runString = "(4)";
5305 if (516 != jtt.bytecode.BC_iinc_4.test(4)) {
5306 fail(runString);
5307 return;
5308 }
5309 // (-1) == 511
5310 runString = "(-1)";
5311 if (511 != jtt.bytecode.BC_iinc_4.test(-1)) {
5312 fail(runString);
5313 return;
5314 }
5315 } catch (Throwable t) {
5316 fail(runString, t);
5317 return;
5318 }
5319 pass();
5320 }
5321
5322 static void jtt_bytecode_BC_iload_0() {
5323 begin("jtt.bytecode.BC_iload_0");
5324 String runString = null;
5325 try {
5326 // (0) == 0
5327 runString = "(0)";
5328 if (0 != jtt.bytecode.BC_iload_0.test(0)) {
5329 fail(runString);
5330 return;
5331 }
5332 // (-1) == -1
5333 runString = "(-1)";
5334 if (-1 != jtt.bytecode.BC_iload_0.test(-1)) {
5335 fail(runString);
5336 return;
5337 }
5338 // (2) == 2
5339 runString = "(2)";
5340 if (2 != jtt.bytecode.BC_iload_0.test(2)) {
5341 fail(runString);
5342 return;
5343 }
5344 // (1000345) == 1000345
5345 runString = "(1000345)";
5346 if (1000345 != jtt.bytecode.BC_iload_0.test(1000345)) {
5347 fail(runString);
5348 return;
5349 }
5350 } catch (Throwable t) {
5351 fail(runString, t);
5352 return;
5353 }
5354 pass();
5355 }
5356
5357 static void jtt_bytecode_BC_iload_0_1() {
5358 begin("jtt.bytecode.BC_iload_0_1");
5359 String runString = null;
5360 try {
5361 // (0) == 1
5362 runString = "(0)";
5363 if (1 != jtt.bytecode.BC_iload_0_1.test(0)) {
5364 fail(runString);
5365 return;
5366 }
5367 // (-1) == 0
5368 runString = "(-1)";
5369 if (0 != jtt.bytecode.BC_iload_0_1.test(-1)) {
5370 fail(runString);
5371 return;
5372 }
5373 // (2) == 3
5374 runString = "(2)";
5375 if (3 != jtt.bytecode.BC_iload_0_1.test(2)) {
5376 fail(runString);
5377 return;
5378 }
5379 // (1000345) == 1000346
5380 runString = "(1000345)";
5381 if (1000346 != jtt.bytecode.BC_iload_0_1.test(1000345)) {
5382 fail(runString);
5383 return;
5384 }
5385 } catch (Throwable t) {
5386 fail(runString, t);
5387 return;
5388 }
5389 pass();
5390 }
5391
5392 static void jtt_bytecode_BC_iload_0_2() {
5393 begin("jtt.bytecode.BC_iload_0_2");
5394 String runString = null;
5395 try {
5396 // (0) == 0
5397 runString = "(0)";
5398 if (0 != jtt.bytecode.BC_iload_0_2.test(0)) {
5399 fail(runString);
5400 return;
5401 }
5402 // (-1) == -1
5403 runString = "(-1)";
5404 if (-1 != jtt.bytecode.BC_iload_0_2.test(-1)) {
5405 fail(runString);
5406 return;
5407 }
5408 // (2) == 2
5409 runString = "(2)";
5410 if (2 != jtt.bytecode.BC_iload_0_2.test(2)) {
5411 fail(runString);
5412 return;
5413 }
5414 // (1000345) == 1000345
5415 runString = "(1000345)";
5416 if (1000345 != jtt.bytecode.BC_iload_0_2.test(1000345)) {
5417 fail(runString);
5418 return;
5419 }
5420 } catch (Throwable t) {
5421 fail(runString, t);
5422 return;
5423 }
5424 pass();
5425 }
5426
5427 static void jtt_bytecode_BC_iload_1() {
5428 begin("jtt.bytecode.BC_iload_1");
5429 String runString = null;
5430 try {
5431 // (1,0) == 0
5432 runString = "(1,0)";
5433 if (0 != jtt.bytecode.BC_iload_1.test(1, 0)) {
5434 fail(runString);
5435 return;
5436 }
5437 // (1,-1) == -1
5438 runString = "(1,-1)";
5439 if (-1 != jtt.bytecode.BC_iload_1.test(1, -1)) {
5440 fail(runString);
5441 return;
5442 }
5443 // (1,2) == 2
5444 runString = "(1,2)";
5445 if (2 != jtt.bytecode.BC_iload_1.test(1, 2)) {
5446 fail(runString);
5447 return;
5448 }
5449 // (1,1000345) == 1000345
5450 runString = "(1,1000345)";
5451 if (1000345 != jtt.bytecode.BC_iload_1.test(1, 1000345)) {
5452 fail(runString);
5453 return;
5454 }
5455 } catch (Throwable t) {
5456 fail(runString, t);
5457 return;
5458 }
5459 pass();
5460 }
5461
5462 static void jtt_bytecode_BC_iload_1_1() {
5463 begin("jtt.bytecode.BC_iload_1_1");
5464 String runString = null;
5465 try {
5466 // (0) == 0
5467 runString = "(0)";
5468 if (0 != jtt.bytecode.BC_iload_1_1.test(0)) {
5469 fail(runString);
5470 return;
5471 }
5472 // (-1) == -1
5473 runString = "(-1)";
5474 if (-1 != jtt.bytecode.BC_iload_1_1.test(-1)) {
5475 fail(runString);
5476 return;
5477 }
5478 // (2) == 2
5479 runString = "(2)";
5480 if (2 != jtt.bytecode.BC_iload_1_1.test(2)) {
5481 fail(runString);
5482 return;
5483 }
5484 // (1000345) == 1000345
5485 runString = "(1000345)";
5486 if (1000345 != jtt.bytecode.BC_iload_1_1.test(1000345)) {
5487 fail(runString);
5488 return;
5489 }
5490 } catch (Throwable t) {
5491 fail(runString, t);
5492 return;
5493 }
5494 pass();
5495 }
5496
5497 static void jtt_bytecode_BC_iload_2() {
5498 begin("jtt.bytecode.BC_iload_2");
5499 String runString = null;
5500 try {
5501 // (1,1,0) == 0
5502 runString = "(1,1,0)";
5503 if (0 != jtt.bytecode.BC_iload_2.test(1, 1, 0)) {
5504 fail(runString);
5505 return;
5506 }
5507 // (1,1,-1) == -1
5508 runString = "(1,1,-1)";
5509 if (-1 != jtt.bytecode.BC_iload_2.test(1, 1, -1)) {
5510 fail(runString);
5511 return;
5512 }
5513 // (1,1,2) == 2
5514 runString = "(1,1,2)";
5515 if (2 != jtt.bytecode.BC_iload_2.test(1, 1, 2)) {
5516 fail(runString);
5517 return;
5518 }
5519 // (1,1,1000345) == 1000345
5520 runString = "(1,1,1000345)";
5521 if (1000345 != jtt.bytecode.BC_iload_2.test(1, 1, 1000345)) {
5522 fail(runString);
5523 return;
5524 }
5525 } catch (Throwable t) {
5526 fail(runString, t);
5527 return;
5528 }
5529 pass();
5530 }
5531
5532 static void jtt_bytecode_BC_iload_3() {
5533 begin("jtt.bytecode.BC_iload_3");
5534 String runString = null;
5535 try {
5536 // (1,1,1,0) == 0
5537 runString = "(1,1,1,0)";
5538 if (0 != jtt.bytecode.BC_iload_3.test(1, 1, 1, 0)) {
5539 fail(runString);
5540 return;
5541 }
5542 // (1,1,1,-1) == -1
5543 runString = "(1,1,1,-1)";
5544 if (-1 != jtt.bytecode.BC_iload_3.test(1, 1, 1, -1)) {
5545 fail(runString);
5546 return;
5547 }
5548 // (1,1,1,2) == 2
5549 runString = "(1,1,1,2)";
5550 if (2 != jtt.bytecode.BC_iload_3.test(1, 1, 1, 2)) {
5551 fail(runString);
5552 return;
5553 }
5554 // (1,1,1,1000345) == 1000345
5555 runString = "(1,1,1,1000345)";
5556 if (1000345 != jtt.bytecode.BC_iload_3.test(1, 1, 1, 1000345)) {
5557 fail(runString);
5558 return;
5559 }
5560 } catch (Throwable t) {
5561 fail(runString, t);
5562 return;
5563 }
5564 pass();
5565 }
5566
5567 static void jtt_bytecode_BC_imul() {
5568 begin("jtt.bytecode.BC_imul");
5569 String runString = null;
5570 try {
5571 // (1,2) == 2
5572 runString = "(1,2)";
5573 if (2 != jtt.bytecode.BC_imul.test(1, 2)) {
5574 fail(runString);
5575 return;
5576 }
5577 // (0,-1) == 0
5578 runString = "(0,-1)";
5579 if (0 != jtt.bytecode.BC_imul.test(0, -1)) {
5580 fail(runString);
5581 return;
5582 }
5583 // (33,67) == 2211
5584 runString = "(33,67)";
5585 if (2211 != jtt.bytecode.BC_imul.test(33, 67)) {
5586 fail(runString);
5587 return;
5588 }
5589 // (1,-1) == -1
5590 runString = "(1,-1)";
5591 if (-1 != jtt.bytecode.BC_imul.test(1, -1)) {
5592 fail(runString);
5593 return;
5594 }
5595 // (-2147483648,1) == -2147483648
5596 runString = "(-2147483648,1)";
5597 if (-2147483648 != jtt.bytecode.BC_imul.test(-2147483648, 1)) {
5598 fail(runString);
5599 return;
5600 }
5601 // (2147483647,-1) == -2147483647
5602 runString = "(2147483647,-1)";
5603 if (-2147483647 != jtt.bytecode.BC_imul.test(2147483647, -1)) {
5604 fail(runString);
5605 return;
5606 }
5607 // (-2147483648,-1) == -2147483648
5608 runString = "(-2147483648,-1)";
5609 if (-2147483648 != jtt.bytecode.BC_imul.test(-2147483648, -1)) {
5610 fail(runString);
5611 return;
5612 }
5613 } catch (Throwable t) {
5614 fail(runString, t);
5615 return;
5616 }
5617 pass();
5618 }
5619
5620 static void jtt_bytecode_BC_ineg() {
5621 begin("jtt.bytecode.BC_ineg");
5622 String runString = null;
5623 try {
5624 // (0) == 0
5625 runString = "(0)";
5626 if (0 != jtt.bytecode.BC_ineg.test(0)) {
5627 fail(runString);
5628 return;
5629 }
5630 // (-1) == 1
5631 runString = "(-1)";
5632 if (1 != jtt.bytecode.BC_ineg.test(-1)) {
5633 fail(runString);
5634 return;
5635 }
5636 // (7263) == -7263
5637 runString = "(7263)";
5638 if (-7263 != jtt.bytecode.BC_ineg.test(7263)) {
5639 fail(runString);
5640 return;
5641 }
5642 // (-2147483648) == -2147483648
5643 runString = "(-2147483648)";
5644 if (-2147483648 != jtt.bytecode.BC_ineg.test(-2147483648)) {
5645 fail(runString);
5646 return;
5647 }
5648 } catch (Throwable t) {
5649 fail(runString, t);
5650 return;
5651 }
5652 pass();
5653 }
5654
5655 static void jtt_bytecode_BC_instanceof() {
5656 begin("jtt.bytecode.BC_instanceof");
5657 String runString = null;
5658 try {
5659 // (0) == false
5660 runString = "(0)";
5661 if (false != jtt.bytecode.BC_instanceof.test(0)) {
5662 fail(runString);
5663 return;
5664 }
5665 // (1) == false
5666 runString = "(1)";
5667 if (false != jtt.bytecode.BC_instanceof.test(1)) {
5668 fail(runString);
5669 return;
5670 }
5671 // (2) == false
5672 runString = "(2)";
5673 if (false != jtt.bytecode.BC_instanceof.test(2)) {
5674 fail(runString);
5675 return;
5676 }
5677 // (3) == false
5678 runString = "(3)";
5679 if (false != jtt.bytecode.BC_instanceof.test(3)) {
5680 fail(runString);
5681 return;
5682 }
5683 // (4) == true
5684 runString = "(4)";
5685 if (true != jtt.bytecode.BC_instanceof.test(4)) {
5686 fail(runString);
5687 return;
5688 }
5689 } catch (Throwable t) {
5690 fail(runString, t);
5691 return;
5692 }
5693 pass();
5694 }
5695
5696 static void jtt_bytecode_BC_invokeinterface() {
5697 begin("jtt.bytecode.BC_invokeinterface");
5698 String runString = null;
5699 try {
5700 // (0) == 0
5701 runString = "(0)";
5702 if (0 != jtt.bytecode.BC_invokeinterface.test(0)) {
5703 fail(runString);
5704 return;
5705 }
5706 // (1) == 1
5707 runString = "(1)";
5708 if (1 != jtt.bytecode.BC_invokeinterface.test(1)) {
5709 fail(runString);
5710 return;
5711 }
5712 // (2) == 2
5713 runString = "(2)";
5714 if (2 != jtt.bytecode.BC_invokeinterface.test(2)) {
5715 fail(runString);
5716 return;
5717 }
5718 // (3) == 3
5719 runString = "(3)";
5720 if (3 != jtt.bytecode.BC_invokeinterface.test(3)) {
5721 fail(runString);
5722 return;
5723 }
5724 // (-4) == -4
5725 runString = "(-4)";
5726 if (-4 != jtt.bytecode.BC_invokeinterface.test(-4)) {
5727 fail(runString);
5728 return;
5729 }
5730 } catch (Throwable t) {
5731 fail(runString, t);
5732 return;
5733 }
5734 pass();
5735 }
5736
5737 static void jtt_bytecode_BC_invokespecial() {
5738 begin("jtt.bytecode.BC_invokespecial");
5739 String runString = null;
5740 try {
5741 // (0) == 0
5742 runString = "(0)";
5743 if (0 != jtt.bytecode.BC_invokespecial.test(0)) {
5744 fail(runString);
5745 return;
5746 }
5747 // (1) == 1
5748 runString = "(1)";
5749 if (1 != jtt.bytecode.BC_invokespecial.test(1)) {
5750 fail(runString);
5751 return;
5752 }
5753 // (2) == 2
5754 runString = "(2)";
5755 if (2 != jtt.bytecode.BC_invokespecial.test(2)) {
5756 fail(runString);
5757 return;
5758 }
5759 // (3) == 3
5760 runString = "(3)";
5761 if (3 != jtt.bytecode.BC_invokespecial.test(3)) {
5762 fail(runString);
5763 return;
5764 }
5765 // (-4) == -4
5766 runString = "(-4)";
5767 if (-4 != jtt.bytecode.BC_invokespecial.test(-4)) {
5768 fail(runString);
5769 return;
5770 }
5771 } catch (Throwable t) {
5772 fail(runString, t);
5773 return;
5774 }
5775 pass();
5776 }
5777
5778 static void jtt_bytecode_BC_invokespecial2() {
5779 begin("jtt.bytecode.BC_invokespecial2");
5780 String runString = null;
5781 try {
5782 // (0) == 7
5783 runString = "(0)";
5784 if (7 != jtt.bytecode.BC_invokespecial2.test(0)) {
5785 fail(runString);
5786 return;
5787 }
5788 // (1) == 8
5789 runString = "(1)";
5790 if (8 != jtt.bytecode.BC_invokespecial2.test(1)) {
5791 fail(runString);
5792 return;
5793 }
5794 // (2) == 9
5795 runString = "(2)";
5796 if (9 != jtt.bytecode.BC_invokespecial2.test(2)) {
5797 fail(runString);
5798 return;
5799 }
5800 // (3) == 10
5801 runString = "(3)";
5802 if (10 != jtt.bytecode.BC_invokespecial2.test(3)) {
5803 fail(runString);
5804 return;
5805 }
5806 // (-4) == 3
5807 runString = "(-4)";
5808 if (3 != jtt.bytecode.BC_invokespecial2.test(-4)) {
5809 fail(runString);
5810 return;
5811 }
5812 } catch (Throwable t) {
5813 fail(runString, t);
5814 return;
5815 }
5816 pass();
5817 }
5818
5819 static void jtt_bytecode_BC_invokestatic() {
5820 begin("jtt.bytecode.BC_invokestatic");
5821 String runString = null;
5822 try {
5823 // (0) == 0
5824 runString = "(0)";
5825 if (0 != jtt.bytecode.BC_invokestatic.test(0)) {
5826 fail(runString);
5827 return;
5828 }
5829 // (1) == 1
5830 runString = "(1)";
5831 if (1 != jtt.bytecode.BC_invokestatic.test(1)) {
5832 fail(runString);
5833 return;
5834 }
5835 // (2) == 2
5836 runString = "(2)";
5837 if (2 != jtt.bytecode.BC_invokestatic.test(2)) {
5838 fail(runString);
5839 return;
5840 }
5841 // (3) == 3
5842 runString = "(3)";
5843 if (3 != jtt.bytecode.BC_invokestatic.test(3)) {
5844 fail(runString);
5845 return;
5846 }
5847 // (-4) == -4
5848 runString = "(-4)";
5849 if (-4 != jtt.bytecode.BC_invokestatic.test(-4)) {
5850 fail(runString);
5851 return;
5852 }
5853 } catch (Throwable t) {
5854 fail(runString, t);
5855 return;
5856 }
5857 pass();
5858 }
5859
5860 static void jtt_bytecode_BC_invokevirtual() {
5861 begin("jtt.bytecode.BC_invokevirtual");
5862 String runString = null;
5863 try {
5864 // (0) == 0
5865 runString = "(0)";
5866 if (0 != jtt.bytecode.BC_invokevirtual.test(0)) {
5867 fail(runString);
5868 return;
5869 }
5870 // (1) == 1
5871 runString = "(1)";
5872 if (1 != jtt.bytecode.BC_invokevirtual.test(1)) {
5873 fail(runString);
5874 return;
5875 }
5876 // (2) == 2
5877 runString = "(2)";
5878 if (2 != jtt.bytecode.BC_invokevirtual.test(2)) {
5879 fail(runString);
5880 return;
5881 }
5882 // (3) == 3
5883 runString = "(3)";
5884 if (3 != jtt.bytecode.BC_invokevirtual.test(3)) {
5885 fail(runString);
5886 return;
5887 }
5888 // (-4) == -4
5889 runString = "(-4)";
5890 if (-4 != jtt.bytecode.BC_invokevirtual.test(-4)) {
5891 fail(runString);
5892 return;
5893 }
5894 } catch (Throwable t) {
5895 fail(runString, t);
5896 return;
5897 }
5898 pass();
5899 }
5900
5901 static void jtt_bytecode_BC_ior() {
5902 begin("jtt.bytecode.BC_ior");
5903 String runString = null;
5904 try {
5905 // (1,2) == 3
5906 runString = "(1,2)";
5907 if (3 != jtt.bytecode.BC_ior.test(1, 2)) {
5908 fail(runString);
5909 return;
5910 }
5911 // (0,-1) == -1
5912 runString = "(0,-1)";
5913 if (-1 != jtt.bytecode.BC_ior.test(0, -1)) {
5914 fail(runString);
5915 return;
5916 }
5917 // (31,63) == 63
5918 runString = "(31,63)";
5919 if (63 != jtt.bytecode.BC_ior.test(31, 63)) {
5920 fail(runString);
5921 return;
5922 }
5923 // (6,4) == 6
5924 runString = "(6,4)";
5925 if (6 != jtt.bytecode.BC_ior.test(6, 4)) {
5926 fail(runString);
5927 return;
5928 }
5929 // (-2147483648,1) == -2147483647
5930 runString = "(-2147483648,1)";
5931 if (-2147483647 != jtt.bytecode.BC_ior.test(-2147483648, 1)) {
5932 fail(runString);
5933 return;
5934 }
5935 } catch (Throwable t) {
5936 fail(runString, t);
5937 return;
5938 }
5939 pass();
5940 }
5941
5942 static void jtt_bytecode_BC_irem() {
5943 begin("jtt.bytecode.BC_irem");
5944 String runString = null;
5945 try {
5946 // (1,2) == 1
5947 runString = "(1,2)";
5948 if (1 != jtt.bytecode.BC_irem.test(1, 2)) {
5949 fail(runString);
5950 return;
5951 }
5952 // (2,-1) == 0
5953 runString = "(2,-1)";
5954 if (0 != jtt.bytecode.BC_irem.test(2, -1)) {
5955 fail(runString);
5956 return;
5957 }
5958 // (256,4) == 0
5959 runString = "(256,4)";
5960 if (0 != jtt.bytecode.BC_irem.test(256, 4)) {
5961 fail(runString);
5962 return;
5963 }
5964 // (135,7) == 2
5965 runString = "(135,7)";
5966 if (2 != jtt.bytecode.BC_irem.test(135, 7)) {
5967 fail(runString);
5968 return;
5969 }
5970 } catch (Throwable t) {
5971 fail(runString, t);
5972 return;
5973 }
5974 pass();
5975 }
5976
5977 static void jtt_bytecode_BC_irem2() {
5978 begin("jtt.bytecode.BC_irem2");
5979 String runString = null;
5980 try {
5981 // (-2147483648,-1) == 0
5982 runString = "(-2147483648,-1)";
5983 if (0 != jtt.bytecode.BC_irem2.test(-2147483648, -1)) {
5984 fail(runString);
5985 return;
5986 }
5987 // (-2147483648,1) == 0
5988 runString = "(-2147483648,1)";
5989 if (0 != jtt.bytecode.BC_irem2.test(-2147483648, 1)) {
5990 fail(runString);
5991 return;
5992 }
5993 } catch (Throwable t) {
5994 fail(runString, t);
5995 return;
5996 }
5997 pass();
5998 }
5999
6000 static void jtt_bytecode_BC_ireturn() {
6001 begin("jtt.bytecode.BC_ireturn");
6002 String runString = null;
6003 try {
6004 // (0) == 0
6005 runString = "(0)";
6006 if (0 != jtt.bytecode.BC_ireturn.test(0)) {
6007 fail(runString);
6008 return;
6009 }
6010 // (1) == 1
6011 runString = "(1)";
6012 if (1 != jtt.bytecode.BC_ireturn.test(1)) {
6013 fail(runString);
6014 return;
6015 }
6016 // (-1) == -1
6017 runString = "(-1)";
6018 if (-1 != jtt.bytecode.BC_ireturn.test(-1)) {
6019 fail(runString);
6020 return;
6021 }
6022 // (256) == 256
6023 runString = "(256)";
6024 if (256 != jtt.bytecode.BC_ireturn.test(256)) {
6025 fail(runString);
6026 return;
6027 }
6028 } catch (Throwable t) {
6029 fail(runString, t);
6030 return;
6031 }
6032 pass();
6033 }
6034
6035 static void jtt_bytecode_BC_ishl() {
6036 begin("jtt.bytecode.BC_ishl");
6037 String runString = null;
6038 try {
6039 // (1,2) == 4
6040 runString = "(1,2)";
6041 if (4 != jtt.bytecode.BC_ishl.test(1, 2)) {
6042 fail(runString);
6043 return;
6044 }
6045 // (0,-1) == 0
6046 runString = "(0,-1)";
6047 if (0 != jtt.bytecode.BC_ishl.test(0, -1)) {
6048 fail(runString);
6049 return;
6050 }
6051 // (31,1) == 62
6052 runString = "(31,1)";
6053 if (62 != jtt.bytecode.BC_ishl.test(31, 1)) {
6054 fail(runString);
6055 return;
6056 }
6057 // (6,4) == 96
6058 runString = "(6,4)";
6059 if (96 != jtt.bytecode.BC_ishl.test(6, 4)) {
6060 fail(runString);
6061 return;
6062 }
6063 // (-2147483648,1) == 0
6064 runString = "(-2147483648,1)";
6065 if (0 != jtt.bytecode.BC_ishl.test(-2147483648, 1)) {
6066 fail(runString);
6067 return;
6068 }
6069 } catch (Throwable t) {
6070 fail(runString, t);
6071 return;
6072 }
6073 pass();
6074 }
6075
6076 static void jtt_bytecode_BC_ishr() {
6077 begin("jtt.bytecode.BC_ishr");
6078 String runString = null;
6079 try {
6080 // (1,2) == 0
6081 runString = "(1,2)";
6082 if (0 != jtt.bytecode.BC_ishr.test(1, 2)) {
6083 fail(runString);
6084 return;
6085 }
6086 // (67,2) == 16
6087 runString = "(67,2)";
6088 if (16 != jtt.bytecode.BC_ishr.test(67, 2)) {
6089 fail(runString);
6090 return;
6091 }
6092 // (31,1) == 15
6093 runString = "(31,1)";
6094 if (15 != jtt.bytecode.BC_ishr.test(31, 1)) {
6095 fail(runString);
6096 return;
6097 }
6098 // (6,4) == 0
6099 runString = "(6,4)";
6100 if (0 != jtt.bytecode.BC_ishr.test(6, 4)) {
6101 fail(runString);
6102 return;
6103 }
6104 // (-2147483648,16) == -32768
6105 runString = "(-2147483648,16)";
6106 if (-32768 != jtt.bytecode.BC_ishr.test(-2147483648, 16)) {
6107 fail(runString);
6108 return;
6109 }
6110 } catch (Throwable t) {
6111 fail(runString, t);
6112 return;
6113 }
6114 pass();
6115 }
6116
6117 static void jtt_bytecode_BC_isub() {
6118 begin("jtt.bytecode.BC_isub");
6119 String runString = null;
6120 try {
6121 // (1,-2) == 3
6122 runString = "(1,-2)";
6123 if (3 != jtt.bytecode.BC_isub.test(1, -2)) {
6124 fail(runString);
6125 return;
6126 }
6127 // (0,1) == -1
6128 runString = "(0,1)";
6129 if (-1 != jtt.bytecode.BC_isub.test(0, 1)) {
6130 fail(runString);
6131 return;
6132 }
6133 // (33,-67) == 100
6134 runString = "(33,-67)";
6135 if (100 != jtt.bytecode.BC_isub.test(33, -67)) {
6136 fail(runString);
6137 return;
6138 }
6139 // (1,1) == 0
6140 runString = "(1,1)";
6141 if (0 != jtt.bytecode.BC_isub.test(1, 1)) {
6142 fail(runString);
6143 return;
6144 }
6145 // (-2147483648,-1) == -2147483647
6146 runString = "(-2147483648,-1)";
6147 if (-2147483647 != jtt.bytecode.BC_isub.test(-2147483648, -1)) {
6148 fail(runString);
6149 return;
6150 }
6151 // (2147483647,-1) == -2147483648
6152 runString = "(2147483647,-1)";
6153 if (-2147483648 != jtt.bytecode.BC_isub.test(2147483647, -1)) {
6154 fail(runString);
6155 return;
6156 }
6157 // (-2147483647,2) == 2147483647
6158 runString = "(-2147483647,2)";
6159 if (2147483647 != jtt.bytecode.BC_isub.test(-2147483647, 2)) {
6160 fail(runString);
6161 return;
6162 }
6163 } catch (Throwable t) {
6164 fail(runString, t);
6165 return;
6166 }
6167 pass();
6168 }
6169
6170 static void jtt_bytecode_BC_iushr() {
6171 begin("jtt.bytecode.BC_iushr");
6172 String runString = null;
6173 try {
6174 // (1,2) == 0
6175 runString = "(1,2)";
6176 if (0 != jtt.bytecode.BC_iushr.test(1, 2)) {
6177 fail(runString);
6178 return;
6179 }
6180 // (67,2) == 16
6181 runString = "(67,2)";
6182 if (16 != jtt.bytecode.BC_iushr.test(67, 2)) {
6183 fail(runString);
6184 return;
6185 }
6186 // (31,1) == 15
6187 runString = "(31,1)";
6188 if (15 != jtt.bytecode.BC_iushr.test(31, 1)) {
6189 fail(runString);
6190 return;
6191 }
6192 // (6,4) == 0
6193 runString = "(6,4)";
6194 if (0 != jtt.bytecode.BC_iushr.test(6, 4)) {
6195 fail(runString);
6196 return;
6197 }
6198 // (-2147483648,16) == 32768
6199 runString = "(-2147483648,16)";
6200 if (32768 != jtt.bytecode.BC_iushr.test(-2147483648, 16)) {
6201 fail(runString);
6202 return;
6203 }
6204 } catch (Throwable t) {
6205 fail(runString, t);
6206 return;
6207 }
6208 pass();
6209 }
6210
6211 static void jtt_bytecode_BC_ixor() {
6212 begin("jtt.bytecode.BC_ixor");
6213 String runString = null;
6214 try {
6215 // (1,2) == 3
6216 runString = "(1,2)";
6217 if (3 != jtt.bytecode.BC_ixor.test(1, 2)) {
6218 fail(runString);
6219 return;
6220 }
6221 // (0,-1) == -1
6222 runString = "(0,-1)";
6223 if (-1 != jtt.bytecode.BC_ixor.test(0, -1)) {
6224 fail(runString);
6225 return;
6226 }
6227 // (31,63) == 32
6228 runString = "(31,63)";
6229 if (32 != jtt.bytecode.BC_ixor.test(31, 63)) {
6230 fail(runString);
6231 return;
6232 }
6233 // (6,4) == 2
6234 runString = "(6,4)";
6235 if (2 != jtt.bytecode.BC_ixor.test(6, 4)) {
6236 fail(runString);
6237 return;
6238 }
6239 // (-2147483648,1) == -2147483647
6240 runString = "(-2147483648,1)";
6241 if (-2147483647 != jtt.bytecode.BC_ixor.test(-2147483648, 1)) {
6242 fail(runString);
6243 return;
6244 }
6245 } catch (Throwable t) {
6246 fail(runString, t);
6247 return;
6248 }
6249 pass();
6250 }
6251
6252 static void jtt_bytecode_BC_l2d() {
6253 begin("jtt.bytecode.BC_l2d");
6254 String runString = null;
6255 try {
6256 // (0) == 0.0
6257 runString = "(0)";
6258 if (0.0 != jtt.bytecode.BC_l2d.test(0L)) {
6259 fail(runString);
6260 return;
6261 }
6262 // (1) == 1.0
6263 runString = "(1)";
6264 if (1.0 != jtt.bytecode.BC_l2d.test(1L)) {
6265 fail(runString);
6266 return;
6267 }
6268 // (-74652389) == -7.4652389E7
6269 runString = "(-74652389)";
6270 if (-7.4652389E7 != jtt.bytecode.BC_l2d.test(-74652389L)) {
6271 fail(runString);
6272 return;
6273 }
6274 } catch (Throwable t) {
6275 fail(runString, t);
6276 return;
6277 }
6278 pass();
6279 }
6280
6281 static void jtt_bytecode_BC_l2f() {
6282 begin("jtt.bytecode.BC_l2f");
6283 String runString = null;
6284 try {
6285 // (0) == 0.0
6286 runString = "(0)";
6287 if (0.0f != jtt.bytecode.BC_l2f.test(0L)) {
6288 fail(runString);
6289 return;
6290 }
6291 // (1) == 1.0
6292 runString = "(1)";
6293 if (1.0f != jtt.bytecode.BC_l2f.test(1L)) {
6294 fail(runString);
6295 return;
6296 }
6297 // (-74652389) == -7.4652392E7
6298 runString = "(-74652389)";
6299 if (-7.4652392E7f != jtt.bytecode.BC_l2f.test(-74652389L)) {
6300 fail(runString);
6301 return;
6302 }
6303 } catch (Throwable t) {
6304 fail(runString, t);
6305 return;
6306 }
6307 pass();
6308 }
6309
6310 static void jtt_bytecode_BC_l2i() {
6311 begin("jtt.bytecode.BC_l2i");
6312 String runString = null;
6313 try {
6314 // (1) == 1
6315 runString = "(1)";
6316 if (1 != jtt.bytecode.BC_l2i.test(1L)) {
6317 fail(runString);
6318 return;
6319 }
6320 // (2) == 2
6321 runString = "(2)";
6322 if (2 != jtt.bytecode.BC_l2i.test(2L)) {
6323 fail(runString);
6324 return;
6325 }
6326 // (3) == 3
6327 runString = "(3)";
6328 if (3 != jtt.bytecode.BC_l2i.test(3L)) {
6329 fail(runString);
6330 return;
6331 }
6332 // (-1) == -1
6333 runString = "(-1)";
6334 if (-1 != jtt.bytecode.BC_l2i.test(-1L)) {
6335 fail(runString);
6336 return;
6337 }
6338 // (-2147483647) == -2147483647
6339 runString = "(-2147483647)";
6340 if (-2147483647 != jtt.bytecode.BC_l2i.test(-2147483647L)) {
6341 fail(runString);
6342 return;
6343 }
6344 // (-2147483648) == -2147483648
6345 runString = "(-2147483648)";
6346 if (-2147483648 != jtt.bytecode.BC_l2i.test(-2147483648L)) {
6347 fail(runString);
6348 return;
6349 }
6350 // (2147483647) == 2147483647
6351 runString = "(2147483647)";
6352 if (2147483647 != jtt.bytecode.BC_l2i.test(2147483647L)) {
6353 fail(runString);
6354 return;
6355 }
6356 } catch (Throwable t) {
6357 fail(runString, t);
6358 return;
6359 }
6360 pass();
6361 }
6362
6363 static void jtt_bytecode_BC_ladd() {
6364 begin("jtt.bytecode.BC_ladd");
6365 String runString = null;
6366 try {
6367 // (1,2) == 3
6368 runString = "(1,2)";
6369 if (3L != jtt.bytecode.BC_ladd.test(1L, 2L)) {
6370 fail(runString);
6371 return;
6372 }
6373 // (0,-1) == -1
6374 runString = "(0,-1)";
6375 if (-1L != jtt.bytecode.BC_ladd.test(0L, -1L)) {
6376 fail(runString);
6377 return;
6378 }
6379 // (33,67) == 100
6380 runString = "(33,67)";
6381 if (100L != jtt.bytecode.BC_ladd.test(33L, 67L)) {
6382 fail(runString);
6383 return;
6384 }
6385 // (1,-1) == 0
6386 runString = "(1,-1)";
6387 if (0L != jtt.bytecode.BC_ladd.test(1L, -1L)) {
6388 fail(runString);
6389 return;
6390 }
6391 // (-2147483648,1) == -2147483647
6392 runString = "(-2147483648,1)";
6393 if (-2147483647L != jtt.bytecode.BC_ladd.test(-2147483648L, 1L)) {
6394 fail(runString);
6395 return;
6396 }
6397 // (2147483647,1) == 2147483648
6398 runString = "(2147483647,1)";
6399 if (2147483648L != jtt.bytecode.BC_ladd.test(2147483647L, 1L)) {
6400 fail(runString);
6401 return;
6402 }
6403 } catch (Throwable t) {
6404 fail(runString, t);
6405 return;
6406 }
6407 pass();
6408 }
6409
6410 static void jtt_bytecode_BC_ladd2() {
6411 begin("jtt.bytecode.BC_ladd2");
6412 String runString = null;
6413 try {
6414 // (1,2) == 3
6415 runString = "(1,2)";
6416 if (3L != jtt.bytecode.BC_ladd2.test(1, 2)) {
6417 fail(runString);
6418 return;
6419 }
6420 // (0,-1) == -1
6421 runString = "(0,-1)";
6422 if (-1L != jtt.bytecode.BC_ladd2.test(0, -1)) {
6423 fail(runString);
6424 return;
6425 }
6426 // (33,67) == 100
6427 runString = "(33,67)";
6428 if (100L != jtt.bytecode.BC_ladd2.test(33, 67)) {
6429 fail(runString);
6430 return;
6431 }
6432 // (1,-1) == 0
6433 runString = "(1,-1)";
6434 if (0L != jtt.bytecode.BC_ladd2.test(1, -1)) {
6435 fail(runString);
6436 return;
6437 }
6438 // (-2147483648,1) == -2147483647
6439 runString = "(-2147483648,1)";
6440 if (-2147483647L != jtt.bytecode.BC_ladd2.test(-2147483648, 1)) {
6441 fail(runString);
6442 return;
6443 }
6444 // (2147483647,1) == 2147483648
6445 runString = "(2147483647,1)";
6446 if (2147483648L != jtt.bytecode.BC_ladd2.test(2147483647, 1)) {
6447 fail(runString);
6448 return;
6449 }
6450 } catch (Throwable t) {
6451 fail(runString, t);
6452 return;
6453 }
6454 pass();
6455 }
6456
6457 static void jtt_bytecode_BC_laload() {
6458 begin("jtt.bytecode.BC_laload");
6459 String runString = null;
6460 try {
6461 // (0) == 0
6462 runString = "(0)";
6463 if (0L != jtt.bytecode.BC_laload.test(0)) {
6464 fail(runString);
6465 return;
6466 }
6467 // (1) == -1
6468 runString = "(1)";
6469 if (-1L != jtt.bytecode.BC_laload.test(1)) {
6470 fail(runString);
6471 return;
6472 }
6473 // (2) == 4
6474 runString = "(2)";
6475 if (4L != jtt.bytecode.BC_laload.test(2)) {
6476 fail(runString);
6477 return;
6478 }
6479 // (3) == 1000000000000
6480 runString = "(3)";
6481 if (1000000000000L != jtt.bytecode.BC_laload.test(3)) {
6482 fail(runString);
6483 return;
6484 }
6485 } catch (Throwable t) {
6486 fail(runString, t);
6487 return;
6488 }
6489 pass();
6490 }
6491
6492 static void jtt_bytecode_BC_land() {
6493 begin("jtt.bytecode.BC_land");
6494 String runString = null;
6495 try {
6496 // (1,2) == 0
6497 runString = "(1,2)";
6498 if (0L != jtt.bytecode.BC_land.test(1L, 2L)) {
6499 fail(runString);
6500 return;
6501 }
6502 // (0,-1) == 0
6503 runString = "(0,-1)";
6504 if (0L != jtt.bytecode.BC_land.test(0L, -1L)) {
6505 fail(runString);
6506 return;
6507 }
6508 // (31,63) == 31
6509 runString = "(31,63)";
6510 if (31L != jtt.bytecode.BC_land.test(31L, 63L)) {
6511 fail(runString);
6512 return;
6513 }
6514 // (6,4) == 4
6515 runString = "(6,4)";
6516 if (4L != jtt.bytecode.BC_land.test(6L, 4L)) {
6517 fail(runString);
6518 return;
6519 }
6520 // (-2147483648,1) == 0
6521 runString = "(-2147483648,1)";
6522 if (0L != jtt.bytecode.BC_land.test(-2147483648L, 1L)) {
6523 fail(runString);
6524 return;
6525 }
6526 } catch (Throwable t) {
6527 fail(runString, t);
6528 return;
6529 }
6530 pass();
6531 }
6532
6533 static void jtt_bytecode_BC_lastore() {
6534 begin("jtt.bytecode.BC_lastore");
6535 String runString = null;
6536 try {
6537 // (0,0) == 0
6538 runString = "(0,0)";
6539 if (0L != jtt.bytecode.BC_lastore.test(0, 0L)) {
6540 fail(runString);
6541 return;
6542 }
6543 // (1,-1) == -1
6544 runString = "(1,-1)";
6545 if (-1L != jtt.bytecode.BC_lastore.test(1, -1L)) {
6546 fail(runString);
6547 return;
6548 }
6549 // (2,11) == 11
6550 runString = "(2,11)";
6551 if (11L != jtt.bytecode.BC_lastore.test(2, 11L)) {
6552 fail(runString);
6553 return;
6554 }
6555 // (3,-14) == -14
6556 runString = "(3,-14)";
6557 if (-14L != jtt.bytecode.BC_lastore.test(3, -14L)) {
6558 fail(runString);
6559 return;
6560 }
6561 } catch (Throwable t) {
6562 fail(runString, t);
6563 return;
6564 }
6565 pass();
6566 }
6567
6568 static void jtt_bytecode_BC_lcmp() {
6569 begin("jtt.bytecode.BC_lcmp");
6570 String runString = null;
6571 try {
6572 // (0,-1) == false
6573 runString = "(0,-1)";
6574 if (false != jtt.bytecode.BC_lcmp.test(0L, -1L)) {
6575 fail(runString);
6576 return;
6577 }
6578 // (77,78) == true
6579 runString = "(77,78)";
6580 if (true != jtt.bytecode.BC_lcmp.test(77L, 78L)) {
6581 fail(runString);
6582 return;
6583 }
6584 // (-1,0) == true
6585 runString = "(-1,0)";
6586 if (true != jtt.bytecode.BC_lcmp.test(-1L, 0L)) {
6587 fail(runString);
6588 return;
6589 }
6590 } catch (Throwable t) {
6591 fail(runString, t);
6592 return;
6593 }
6594 pass();
6595 }
6596
6597 static void jtt_bytecode_BC_ldc_01() {
6598 begin("jtt.bytecode.BC_ldc_01");
6599 String runString = null;
6600 try {
6601 // (0) == -123
6602 runString = "(0)";
6603 if (-123 != jtt.bytecode.BC_ldc_01.test(0)) {
6604 fail(runString);
6605 return;
6606 }
6607 } catch (Throwable t) {
6608 fail(runString, t);
6609 return;
6610 }
6611 pass();
6612 }
6613
6614 static void jtt_bytecode_BC_ldc_02() {
6615 begin("jtt.bytecode.BC_ldc_02");
6616 String runString = null;
6617 try {
6618 // (0) == -2.4
6619 runString = "(0)";
6620 if (-2.4f != jtt.bytecode.BC_ldc_02.test(0)) {
6621 fail(runString);
6622 return;
6623 }
6624 } catch (Throwable t) {
6625 fail(runString, t);
6626 return;
6627 }
6628 pass();
6629 }
6630
6631 static void jtt_bytecode_BC_ldc_03() {
6632 begin("jtt.bytecode.BC_ldc_03");
6633 String runString = null;
6634 try {
6635 // (0) == -123
6636 runString = "(0)";
6637 if (-123L != jtt.bytecode.BC_ldc_03.test(0)) {
6638 fail(runString);
6639 return;
6640 }
6641 } catch (Throwable t) {
6642 fail(runString, t);
6643 return;
6644 }
6645 pass();
6646 }
6647
6648 static void jtt_bytecode_BC_ldc_04() {
6649 begin("jtt.bytecode.BC_ldc_04");
6650 String runString = null;
6651 try {
6652 // (0) == "xyz"
6653 runString = "(0)";
6654 if (!"xyz".equals(jtt.bytecode.BC_ldc_04.test(0))) {
6655 fail(runString);
6656 return;
6657 }
6658 } catch (Throwable t) {
6659 fail(runString, t);
6660 return;
6661 }
6662 pass();
6663 }
6664
6665 static void jtt_bytecode_BC_ldc_05() {
6666 begin("jtt.bytecode.BC_ldc_05");
6667 String runString = null;
6668 try {
6669 // (0) == -2.33
6670 runString = "(0)";
6671 if (-2.33 != jtt.bytecode.BC_ldc_05.test(0)) {
6672 fail(runString);
6673 return;
6674 }
6675 } catch (Throwable t) {
6676 fail(runString, t);
6677 return;
6678 }
6679 pass();
6680 }
6681
6682 static void jtt_bytecode_BC_ldc_06() {
6683 begin("jtt.bytecode.BC_ldc_06");
6684 String runString = null;
6685 try {
6686 // (0) == "jtt.bytecode.BC_ldc_06"
6687 runString = "(0)";
6688 if (!"jtt.bytecode.BC_ldc_06"
6689 .equals(jtt.bytecode.BC_ldc_06.test(0))) {
6690 fail(runString);
6691 return;
6692 }
6693 } catch (Throwable t) {
6694 fail(runString, t);
6695 return;
6696 }
6697 pass();
6698 }
6699
6700 static void jtt_bytecode_BC_ldiv() {
6701 begin("jtt.bytecode.BC_ldiv");
6702 String runString = null;
6703 try {
6704 // (1,2) == 0
6705 runString = "(1,2)";
6706 if (0L != jtt.bytecode.BC_ldiv.test(1L, 2L)) {
6707 fail(runString);
6708 return;
6709 }
6710 // (2,-1) == -2
6711 runString = "(2,-1)";
6712 if (-2L != jtt.bytecode.BC_ldiv.test(2L, -1L)) {
6713 fail(runString);
6714 return;
6715 }
6716 // (256,4) == 64
6717 runString = "(256,4)";
6718 if (64L != jtt.bytecode.BC_ldiv.test(256L, 4L)) {
6719 fail(runString);
6720 return;
6721 }
6722 // (135,7) == 19
6723 runString = "(135,7)";
6724 if (19L != jtt.bytecode.BC_ldiv.test(135L, 7L)) {
6725 fail(runString);
6726 return;
6727 }
6728 } catch (Throwable t) {
6729 fail(runString, t);
6730 return;
6731 }
6732 pass();
6733 }
6734
6735 static void jtt_bytecode_BC_ldiv2() {
6736 begin("jtt.bytecode.BC_ldiv2");
6737 String runString = null;
6738 try {
6739 // (-9223372036854775808,-1) == -9223372036854775808
6740 runString = "(-9223372036854775808,-1)";
6741 if (-9223372036854775808L != jtt.bytecode.BC_ldiv2.test(
6742 -9223372036854775808L, -1)) {
6743 fail(runString);
6744 return;
6745 }
6746 // (-9223372036854775808,1) == -9223372036854775808
6747 runString = "(-9223372036854775808,1)";
6748 if (-9223372036854775808L != jtt.bytecode.BC_ldiv2.test(
6749 -9223372036854775808L, 1)) {
6750 fail(runString);
6751 return;
6752 }
6753 } catch (Throwable t) {
6754 fail(runString, t);
6755 return;
6756 }
6757 pass();
6758 }
6759
6760 static void jtt_bytecode_BC_lload_0() {
6761 begin("jtt.bytecode.BC_lload_0");
6762 String runString = null;
6763 try {
6764 // (1) == 1
6765 runString = "(1)";
6766 if (1L != jtt.bytecode.BC_lload_0.test(1L)) {
6767 fail(runString);
6768 return;
6769 }
6770 // (-3) == -3
6771 runString = "(-3)";
6772 if (-3L != jtt.bytecode.BC_lload_0.test(-3L)) {
6773 fail(runString);
6774 return;
6775 }
6776 // (10000) == 10000
6777 runString = "(10000)";
6778 if (10000L != jtt.bytecode.BC_lload_0.test(10000L)) {
6779 fail(runString);
6780 return;
6781 }
6782 } catch (Throwable t) {
6783 fail(runString, t);
6784 return;
6785 }
6786 pass();
6787 }
6788
6789 static void jtt_bytecode_BC_lload_01() {
6790 begin("jtt.bytecode.BC_lload_01");
6791 String runString = null;
6792 try {
6793 // (1) == 0
6794 runString = "(1)";
6795 if (0L != jtt.bytecode.BC_lload_01.test(1)) {
6796 fail(runString);
6797 return;
6798 }
6799 // (-3) == 0
6800 runString = "(-3)";
6801 if (0L != jtt.bytecode.BC_lload_01.test(-3)) {
6802 fail(runString);
6803 return;
6804 }
6805 // (100) == 0
6806 runString = "(100)";
6807 if (0L != jtt.bytecode.BC_lload_01.test(100)) {
6808 fail(runString);
6809 return;
6810 }
6811 } catch (Throwable t) {
6812 fail(runString, t);
6813 return;
6814 }
6815 pass();
6816 }
6817
6818 static void jtt_bytecode_BC_lload_1() {
6819 begin("jtt.bytecode.BC_lload_1");
6820 String runString = null;
6821 try {
6822 // (1,1) == 1
6823 runString = "(1,1)";
6824 if (1L != jtt.bytecode.BC_lload_1.test(1, 1L)) {
6825 fail(runString);
6826 return;
6827 }
6828 // (1,-3) == -3
6829 runString = "(1,-3)";
6830 if (-3L != jtt.bytecode.BC_lload_1.test(1, -3L)) {
6831 fail(runString);
6832 return;
6833 }
6834 // (1,10000) == 10000
6835 runString = "(1,10000)";
6836 if (10000L != jtt.bytecode.BC_lload_1.test(1, 10000L)) {
6837 fail(runString);
6838 return;
6839 }
6840 } catch (Throwable t) {
6841 fail(runString, t);
6842 return;
6843 }
6844 pass();
6845 }
6846
6847 static void jtt_bytecode_BC_lload_2() {
6848 begin("jtt.bytecode.BC_lload_2");
6849 String runString = null;
6850 try {
6851 // (1,1,1) == 1
6852 runString = "(1,1,1)";
6853 if (1L != jtt.bytecode.BC_lload_2.test(1, 1, 1L)) {
6854 fail(runString);
6855 return;
6856 }
6857 // (1,1,-3) == -3
6858 runString = "(1,1,-3)";
6859 if (-3L != jtt.bytecode.BC_lload_2.test(1, 1, -3L)) {
6860 fail(runString);
6861 return;
6862 }
6863 // (1,1,10000) == 10000
6864 runString = "(1,1,10000)";
6865 if (10000L != jtt.bytecode.BC_lload_2.test(1, 1, 10000L)) {
6866 fail(runString);
6867 return;
6868 }
6869 } catch (Throwable t) {
6870 fail(runString, t);
6871 return;
6872 }
6873 pass();
6874 }
6875
6876 static void jtt_bytecode_BC_lload_3() {
6877 begin("jtt.bytecode.BC_lload_3");
6878 String runString = null;
6879 try {
6880 // (1,1,1,1) == 1
6881 runString = "(1,1,1,1)";
6882 if (1L != jtt.bytecode.BC_lload_3.test(1, 1, 1, 1L)) {
6883 fail(runString);
6884 return;
6885 }
6886 // (1,1,1,-3) == -3
6887 runString = "(1,1,1,-3)";
6888 if (-3L != jtt.bytecode.BC_lload_3.test(1, 1, 1, -3L)) {
6889 fail(runString);
6890 return;
6891 }
6892 // (1,1,1,10000) == 10000
6893 runString = "(1,1,1,10000)";
6894 if (10000L != jtt.bytecode.BC_lload_3.test(1, 1, 1, 10000L)) {
6895 fail(runString);
6896 return;
6897 }
6898 } catch (Throwable t) {
6899 fail(runString, t);
6900 return;
6901 }
6902 pass();
6903 }
6904
6905 static void jtt_bytecode_BC_lmul() {
6906 begin("jtt.bytecode.BC_lmul");
6907 String runString = null;
6908 try {
6909 // (1,2) == 2
6910 runString = "(1,2)";
6911 if (2L != jtt.bytecode.BC_lmul.test(1L, 2L)) {
6912 fail(runString);
6913 return;
6914 }
6915 // (0,-1) == 0
6916 runString = "(0,-1)";
6917 if (0L != jtt.bytecode.BC_lmul.test(0L, -1L)) {
6918 fail(runString);
6919 return;
6920 }
6921 // (33,67) == 2211
6922 runString = "(33,67)";
6923 if (2211L != jtt.bytecode.BC_lmul.test(33L, 67L)) {
6924 fail(runString);
6925 return;
6926 }
6927 // (1,-1) == -1
6928 runString = "(1,-1)";
6929 if (-1L != jtt.bytecode.BC_lmul.test(1L, -1L)) {
6930 fail(runString);
6931 return;
6932 }
6933 // (-2147483648,1) == -2147483648
6934 runString = "(-2147483648,1)";
6935 if (-2147483648L != jtt.bytecode.BC_lmul.test(-2147483648L, 1L)) {
6936 fail(runString);
6937 return;
6938 }
6939 // (2147483647,-1) == -2147483647
6940 runString = "(2147483647,-1)";
6941 if (-2147483647L != jtt.bytecode.BC_lmul.test(2147483647L, -1L)) {
6942 fail(runString);
6943 return;
6944 }
6945 // (-2147483648,-1) == 2147483648
6946 runString = "(-2147483648,-1)";
6947 if (2147483648L != jtt.bytecode.BC_lmul.test(-2147483648L, -1L)) {
6948 fail(runString);
6949 return;
6950 }
6951 // (1000000,1000000) == 1000000000000
6952 runString = "(1000000,1000000)";
6953 if (1000000000000L != jtt.bytecode.BC_lmul.test(1000000L, 1000000L)) {
6954 fail(runString);
6955 return;
6956 }
6957 } catch (Throwable t) {
6958 fail(runString, t);
6959 return;
6960 }
6961 pass();
6962 }
6963
6964 static void jtt_bytecode_BC_lneg() {
6965 begin("jtt.bytecode.BC_lneg");
6966 String runString = null;
6967 try {
6968 // (0) == 0
6969 runString = "(0)";
6970 if (0L != jtt.bytecode.BC_lneg.test(0L)) {
6971 fail(runString);
6972 return;
6973 }
6974 // (-1) == 1
6975 runString = "(-1)";
6976 if (1L != jtt.bytecode.BC_lneg.test(-1L)) {
6977 fail(runString);
6978 return;
6979 }
6980 // (7263) == -7263
6981 runString = "(7263)";
6982 if (-7263L != jtt.bytecode.BC_lneg.test(7263L)) {
6983 fail(runString);
6984 return;
6985 }
6986 // (-2147483648) == 2147483648
6987 runString = "(-2147483648)";
6988 if (2147483648L != jtt.bytecode.BC_lneg.test(-2147483648L)) {
6989 fail(runString);
6990 return;
6991 }
6992 } catch (Throwable t) {
6993 fail(runString, t);
6994 return;
6995 }
6996 pass();
6997 }
6998
6999 static void jtt_bytecode_BC_lookupswitch01() {
7000 begin("jtt.bytecode.BC_lookupswitch01");
7001 String runString = null;
7002 try {
7003 // (0) == 42
7004 runString = "(0)";
7005 if (42 != jtt.bytecode.BC_lookupswitch01.test(0)) {
7006 fail(runString);
7007 return;
7008 }
7009 // (1) == 42
7010 runString = "(1)";
7011 if (42 != jtt.bytecode.BC_lookupswitch01.test(1)) {
7012 fail(runString);
7013 return;
7014 }
7015 // (66) == 42
7016 runString = "(66)";
7017 if (42 != jtt.bytecode.BC_lookupswitch01.test(66)) {
7018 fail(runString);
7019 return;
7020 }
7021 // (67) == 0
7022 runString = "(67)";
7023 if (0 != jtt.bytecode.BC_lookupswitch01.test(67)) {
7024 fail(runString);
7025 return;
7026 }
7027 // (68) == 42
7028 runString = "(68)";
7029 if (42 != jtt.bytecode.BC_lookupswitch01.test(68)) {
7030 fail(runString);
7031 return;
7032 }
7033 // (96) == 42
7034 runString = "(96)";
7035 if (42 != jtt.bytecode.BC_lookupswitch01.test(96)) {
7036 fail(runString);
7037 return;
7038 }
7039 // (97) == 1
7040 runString = "(97)";
7041 if (1 != jtt.bytecode.BC_lookupswitch01.test(97)) {
7042 fail(runString);
7043 return;
7044 }
7045 // (98) == 42
7046 runString = "(98)";
7047 if (42 != jtt.bytecode.BC_lookupswitch01.test(98)) {
7048 fail(runString);
7049 return;
7050 }
7051 // (106) == 42
7052 runString = "(106)";
7053 if (42 != jtt.bytecode.BC_lookupswitch01.test(106)) {
7054 fail(runString);
7055 return;
7056 }
7057 // (107) == 2
7058 runString = "(107)";
7059 if (2 != jtt.bytecode.BC_lookupswitch01.test(107)) {
7060 fail(runString);
7061 return;
7062 }
7063 // (108) == 42
7064 runString = "(108)";
7065 if (42 != jtt.bytecode.BC_lookupswitch01.test(108)) {
7066 fail(runString);
7067 return;
7068 }
7069 // (132) == 42
7070 runString = "(132)";
7071 if (42 != jtt.bytecode.BC_lookupswitch01.test(132)) {
7072 fail(runString);
7073 return;
7074 }
7075 // (133) == 3
7076 runString = "(133)";
7077 if (3 != jtt.bytecode.BC_lookupswitch01.test(133)) {
7078 fail(runString);
7079 return;
7080 }
7081 // (134) == 42
7082 runString = "(134)";
7083 if (42 != jtt.bytecode.BC_lookupswitch01.test(134)) {
7084 fail(runString);
7085 return;
7086 }
7087 // (211) == 42
7088 runString = "(211)";
7089 if (42 != jtt.bytecode.BC_lookupswitch01.test(211)) {
7090 fail(runString);
7091 return;
7092 }
7093 // (212) == 4
7094 runString = "(212)";
7095 if (4 != jtt.bytecode.BC_lookupswitch01.test(212)) {
7096 fail(runString);
7097 return;
7098 }
7099 // (213) == 42
7100 runString = "(213)";
7101 if (42 != jtt.bytecode.BC_lookupswitch01.test(213)) {
7102 fail(runString);
7103 return;
7104 }
7105 } catch (Throwable t) {
7106 fail(runString, t);
7107 return;
7108 }
7109 pass();
7110 }
7111
7112 static void jtt_bytecode_BC_lookupswitch02() {
7113 begin("jtt.bytecode.BC_lookupswitch02");
7114 String runString = null;
7115 try {
7116 // (0) == 42
7117 runString = "(0)";
7118 if (42 != jtt.bytecode.BC_lookupswitch02.test(0)) {
7119 fail(runString);
7120 return;
7121 }
7122 // (1) == 42
7123 runString = "(1)";
7124 if (42 != jtt.bytecode.BC_lookupswitch02.test(1)) {
7125 fail(runString);
7126 return;
7127 }
7128 // (66) == 42
7129 runString = "(66)";
7130 if (42 != jtt.bytecode.BC_lookupswitch02.test(66)) {
7131 fail(runString);
7132 return;
7133 }
7134 // (67) == 0
7135 runString = "(67)";
7136 if (0 != jtt.bytecode.BC_lookupswitch02.test(67)) {
7137 fail(runString);
7138 return;
7139 }
7140 // (68) == 42
7141 runString = "(68)";
7142 if (42 != jtt.bytecode.BC_lookupswitch02.test(68)) {
7143 fail(runString);
7144 return;
7145 }
7146 // (96) == 42
7147 runString = "(96)";
7148 if (42 != jtt.bytecode.BC_lookupswitch02.test(96)) {
7149 fail(runString);
7150 return;
7151 }
7152 // (97) == 1
7153 runString = "(97)";
7154 if (1 != jtt.bytecode.BC_lookupswitch02.test(97)) {
7155 fail(runString);
7156 return;
7157 }
7158 // (98) == 42
7159 runString = "(98)";
7160 if (42 != jtt.bytecode.BC_lookupswitch02.test(98)) {
7161 fail(runString);
7162 return;
7163 }
7164 // (106) == 42
7165 runString = "(106)";
7166 if (42 != jtt.bytecode.BC_lookupswitch02.test(106)) {
7167 fail(runString);
7168 return;
7169 }
7170 // (107) == 2
7171 runString = "(107)";
7172 if (2 != jtt.bytecode.BC_lookupswitch02.test(107)) {
7173 fail(runString);
7174 return;
7175 }
7176 // (108) == 42
7177 runString = "(108)";
7178 if (42 != jtt.bytecode.BC_lookupswitch02.test(108)) {
7179 fail(runString);
7180 return;
7181 }
7182 // (132) == 42
7183 runString = "(132)";
7184 if (42 != jtt.bytecode.BC_lookupswitch02.test(132)) {
7185 fail(runString);
7186 return;
7187 }
7188 // (133) == 3
7189 runString = "(133)";
7190 if (3 != jtt.bytecode.BC_lookupswitch02.test(133)) {
7191 fail(runString);
7192 return;
7193 }
7194 // (134) == 42
7195 runString = "(134)";
7196 if (42 != jtt.bytecode.BC_lookupswitch02.test(134)) {
7197 fail(runString);
7198 return;
7199 }
7200 // (211) == 42
7201 runString = "(211)";
7202 if (42 != jtt.bytecode.BC_lookupswitch02.test(211)) {
7203 fail(runString);
7204 return;
7205 }
7206 // (212) == 4
7207 runString = "(212)";
7208 if (4 != jtt.bytecode.BC_lookupswitch02.test(212)) {
7209 fail(runString);
7210 return;
7211 }
7212 // (213) == 42
7213 runString = "(213)";
7214 if (42 != jtt.bytecode.BC_lookupswitch02.test(213)) {
7215 fail(runString);
7216 return;
7217 }
7218 // (-121) == 42
7219 runString = "(-121)";
7220 if (42 != jtt.bytecode.BC_lookupswitch02.test(-121)) {
7221 fail(runString);
7222 return;
7223 }
7224 // (-122) == 5
7225 runString = "(-122)";
7226 if (5 != jtt.bytecode.BC_lookupswitch02.test(-122)) {
7227 fail(runString);
7228 return;
7229 }
7230 // (-123) == 42
7231 runString = "(-123)";
7232 if (42 != jtt.bytecode.BC_lookupswitch02.test(-123)) {
7233 fail(runString);
7234 return;
7235 }
7236 } catch (Throwable t) {
7237 fail(runString, t);
7238 return;
7239 }
7240 pass();
7241 }
7242
7243 static void jtt_bytecode_BC_lookupswitch03() {
7244 begin("jtt.bytecode.BC_lookupswitch03");
7245 String runString = null;
7246 try {
7247 // (0) == 42
7248 runString = "(0)";
7249 if (42 != jtt.bytecode.BC_lookupswitch03.test(0)) {
7250 fail(runString);
7251 return;
7252 }
7253 // (1) == 42
7254 runString = "(1)";
7255 if (42 != jtt.bytecode.BC_lookupswitch03.test(1)) {
7256 fail(runString);
7257 return;
7258 }
7259 // (66) == 42
7260 runString = "(66)";
7261 if (42 != jtt.bytecode.BC_lookupswitch03.test(66)) {
7262 fail(runString);
7263 return;
7264 }
7265 // (67) == 0
7266 runString = "(67)";
7267 if (0 != jtt.bytecode.BC_lookupswitch03.test(67)) {
7268 fail(runString);
7269 return;
7270 }
7271 // (68) == 42
7272 runString = "(68)";
7273 if (42 != jtt.bytecode.BC_lookupswitch03.test(68)) {
7274 fail(runString);
7275 return;
7276 }
7277 // (96) == 42
7278 runString = "(96)";
7279 if (42 != jtt.bytecode.BC_lookupswitch03.test(96)) {
7280 fail(runString);
7281 return;
7282 }
7283 // (97) == 1
7284 runString = "(97)";
7285 if (1 != jtt.bytecode.BC_lookupswitch03.test(97)) {
7286 fail(runString);
7287 return;
7288 }
7289 // (98) == 42
7290 runString = "(98)";
7291 if (42 != jtt.bytecode.BC_lookupswitch03.test(98)) {
7292 fail(runString);
7293 return;
7294 }
7295 // (106) == 42
7296 runString = "(106)";
7297 if (42 != jtt.bytecode.BC_lookupswitch03.test(106)) {
7298 fail(runString);
7299 return;
7300 }
7301 // (107) == 2
7302 runString = "(107)";
7303 if (2 != jtt.bytecode.BC_lookupswitch03.test(107)) {
7304 fail(runString);
7305 return;
7306 }
7307 // (108) == 42
7308 runString = "(108)";
7309 if (42 != jtt.bytecode.BC_lookupswitch03.test(108)) {
7310 fail(runString);
7311 return;
7312 }
7313 // (132) == 42
7314 runString = "(132)";
7315 if (42 != jtt.bytecode.BC_lookupswitch03.test(132)) {
7316 fail(runString);
7317 return;
7318 }
7319 // (133) == 3
7320 runString = "(133)";
7321 if (3 != jtt.bytecode.BC_lookupswitch03.test(133)) {
7322 fail(runString);
7323 return;
7324 }
7325 // (134) == 42
7326 runString = "(134)";
7327 if (42 != jtt.bytecode.BC_lookupswitch03.test(134)) {
7328 fail(runString);
7329 return;
7330 }
7331 // (211) == 42
7332 runString = "(211)";
7333 if (42 != jtt.bytecode.BC_lookupswitch03.test(211)) {
7334 fail(runString);
7335 return;
7336 }
7337 // (212) == 4
7338 runString = "(212)";
7339 if (4 != jtt.bytecode.BC_lookupswitch03.test(212)) {
7340 fail(runString);
7341 return;
7342 }
7343 // (213) == 42
7344 runString = "(213)";
7345 if (42 != jtt.bytecode.BC_lookupswitch03.test(213)) {
7346 fail(runString);
7347 return;
7348 }
7349 // (-121) == 42
7350 runString = "(-121)";
7351 if (42 != jtt.bytecode.BC_lookupswitch03.test(-121)) {
7352 fail(runString);
7353 return;
7354 }
7355 // (-122) == 5
7356 runString = "(-122)";
7357 if (5 != jtt.bytecode.BC_lookupswitch03.test(-122)) {
7358 fail(runString);
7359 return;
7360 }
7361 // (-123) == 42
7362 runString = "(-123)";
7363 if (42 != jtt.bytecode.BC_lookupswitch03.test(-123)) {
7364 fail(runString);
7365 return;
7366 }
7367 } catch (Throwable t) {
7368 fail(runString, t);
7369 return;
7370 }
7371 pass();
7372 }
7373
7374 static void jtt_bytecode_BC_lookupswitch04() {
7375 begin("jtt.bytecode.BC_lookupswitch04");
7376 String runString = null;
7377 try {
7378 // (0) == 42
7379 runString = "(0)";
7380 if (42 != jtt.bytecode.BC_lookupswitch04.test(0)) {
7381 fail(runString);
7382 return;
7383 }
7384 // (1) == 42
7385 runString = "(1)";
7386 if (42 != jtt.bytecode.BC_lookupswitch04.test(1)) {
7387 fail(runString);
7388 return;
7389 }
7390 // (66) == 42
7391 runString = "(66)";
7392 if (42 != jtt.bytecode.BC_lookupswitch04.test(66)) {
7393 fail(runString);
7394 return;
7395 }
7396 // (67) == 0
7397 runString = "(67)";
7398 if (0 != jtt.bytecode.BC_lookupswitch04.test(67)) {
7399 fail(runString);
7400 return;
7401 }
7402 // (68) == 42
7403 runString = "(68)";
7404 if (42 != jtt.bytecode.BC_lookupswitch04.test(68)) {
7405 fail(runString);
7406 return;
7407 }
7408 // (96) == 42
7409 runString = "(96)";
7410 if (42 != jtt.bytecode.BC_lookupswitch04.test(96)) {
7411 fail(runString);
7412 return;
7413 }
7414 // (97) == 1
7415 runString = "(97)";
7416 if (1 != jtt.bytecode.BC_lookupswitch04.test(97)) {
7417 fail(runString);
7418 return;
7419 }
7420 // (98) == 42
7421 runString = "(98)";
7422 if (42 != jtt.bytecode.BC_lookupswitch04.test(98)) {
7423 fail(runString);
7424 return;
7425 }
7426 // (106) == 42
7427 runString = "(106)";
7428 if (42 != jtt.bytecode.BC_lookupswitch04.test(106)) {
7429 fail(runString);
7430 return;
7431 }
7432 // (107) == 2
7433 runString = "(107)";
7434 if (2 != jtt.bytecode.BC_lookupswitch04.test(107)) {
7435 fail(runString);
7436 return;
7437 }
7438 // (108) == 42
7439 runString = "(108)";
7440 if (42 != jtt.bytecode.BC_lookupswitch04.test(108)) {
7441 fail(runString);
7442 return;
7443 }
7444 // (132) == 42
7445 runString = "(132)";
7446 if (42 != jtt.bytecode.BC_lookupswitch04.test(132)) {
7447 fail(runString);
7448 return;
7449 }
7450 // (133) == 3
7451 runString = "(133)";
7452 if (3 != jtt.bytecode.BC_lookupswitch04.test(133)) {
7453 fail(runString);
7454 return;
7455 }
7456 // (134) == 42
7457 runString = "(134)";
7458 if (42 != jtt.bytecode.BC_lookupswitch04.test(134)) {
7459 fail(runString);
7460 return;
7461 }
7462 // (211) == 42
7463 runString = "(211)";
7464 if (42 != jtt.bytecode.BC_lookupswitch04.test(211)) {
7465 fail(runString);
7466 return;
7467 }
7468 // (212) == 4
7469 runString = "(212)";
7470 if (4 != jtt.bytecode.BC_lookupswitch04.test(212)) {
7471 fail(runString);
7472 return;
7473 }
7474 // (213) == 42
7475 runString = "(213)";
7476 if (42 != jtt.bytecode.BC_lookupswitch04.test(213)) {
7477 fail(runString);
7478 return;
7479 }
7480 // (-121) == 42
7481 runString = "(-121)";
7482 if (42 != jtt.bytecode.BC_lookupswitch04.test(-121)) {
7483 fail(runString);
7484 return;
7485 }
7486 // (-122) == 5
7487 runString = "(-122)";
7488 if (5 != jtt.bytecode.BC_lookupswitch04.test(-122)) {
7489 fail(runString);
7490 return;
7491 }
7492 // (-123) == 42
7493 runString = "(-123)";
7494 if (42 != jtt.bytecode.BC_lookupswitch04.test(-123)) {
7495 fail(runString);
7496 return;
7497 }
7498 } catch (Throwable t) {
7499 fail(runString, t);
7500 return;
7501 }
7502 pass();
7503 }
7504
7505 static void jtt_bytecode_BC_lor() {
7506 begin("jtt.bytecode.BC_lor");
7507 String runString = null;
7508 try {
7509 // (1,2) == 3
7510 runString = "(1,2)";
7511 if (3L != jtt.bytecode.BC_lor.test(1L, 2L)) {
7512 fail(runString);
7513 return;
7514 }
7515 // (0,-1) == -1
7516 runString = "(0,-1)";
7517 if (-1L != jtt.bytecode.BC_lor.test(0L, -1L)) {
7518 fail(runString);
7519 return;
7520 }
7521 // (31,63) == 63
7522 runString = "(31,63)";
7523 if (63L != jtt.bytecode.BC_lor.test(31L, 63L)) {
7524 fail(runString);
7525 return;
7526 }
7527 // (6,4) == 6
7528 runString = "(6,4)";
7529 if (6L != jtt.bytecode.BC_lor.test(6L, 4L)) {
7530 fail(runString);
7531 return;
7532 }
7533 // (-2147483648,1) == -2147483647
7534 runString = "(-2147483648,1)";
7535 if (-2147483647L != jtt.bytecode.BC_lor.test(-2147483648L, 1L)) {
7536 fail(runString);
7537 return;
7538 }
7539 } catch (Throwable t) {
7540 fail(runString, t);
7541 return;
7542 }
7543 pass();
7544 }
7545
7546 static void jtt_bytecode_BC_lrem() {
7547 begin("jtt.bytecode.BC_lrem");
7548 String runString = null;
7549 try {
7550 // (1,2) == 1
7551 runString = "(1,2)";
7552 if (1L != jtt.bytecode.BC_lrem.test(1L, 2L)) {
7553 fail(runString);
7554 return;
7555 }
7556 // (2,-1) == 0
7557 runString = "(2,-1)";
7558 if (0L != jtt.bytecode.BC_lrem.test(2L, -1L)) {
7559 fail(runString);
7560 return;
7561 }
7562 // (256,4) == 0
7563 runString = "(256,4)";
7564 if (0L != jtt.bytecode.BC_lrem.test(256L, 4L)) {
7565 fail(runString);
7566 return;
7567 }
7568 // (135,7) == 2
7569 runString = "(135,7)";
7570 if (2L != jtt.bytecode.BC_lrem.test(135L, 7L)) {
7571 fail(runString);
7572 return;
7573 }
7574 } catch (Throwable t) {
7575 fail(runString, t);
7576 return;
7577 }
7578 pass();
7579 }
7580
7581 static void jtt_bytecode_BC_lrem2() {
7582 begin("jtt.bytecode.BC_lrem2");
7583 String runString = null;
7584 try {
7585 // (-9223372036854775808,-1) == 0
7586 runString = "(-9223372036854775808,-1)";
7587 if (0L != jtt.bytecode.BC_lrem2.test(-9223372036854775808L, -1)) {
7588 fail(runString);
7589 return;
7590 }
7591 // (-9223372036854775808,1) == 0
7592 runString = "(-9223372036854775808,1)";
7593 if (0L != jtt.bytecode.BC_lrem2.test(-9223372036854775808L, 1)) {
7594 fail(runString);
7595 return;
7596 }
7597 } catch (Throwable t) {
7598 fail(runString, t);
7599 return;
7600 }
7601 pass();
7602 }
7603
7604 static void jtt_bytecode_BC_lreturn() {
7605 begin("jtt.bytecode.BC_lreturn");
7606 String runString = null;
7607 try {
7608 // (0) == 0
7609 runString = "(0)";
7610 if (0L != jtt.bytecode.BC_lreturn.test(0L)) {
7611 fail(runString);
7612 return;
7613 }
7614 // (1) == 1
7615 runString = "(1)";
7616 if (1L != jtt.bytecode.BC_lreturn.test(1L)) {
7617 fail(runString);
7618 return;
7619 }
7620 // (-1) == -1
7621 runString = "(-1)";
7622 if (-1L != jtt.bytecode.BC_lreturn.test(-1L)) {
7623 fail(runString);
7624 return;
7625 }
7626 // (256) == 256
7627 runString = "(256)";
7628 if (256L != jtt.bytecode.BC_lreturn.test(256L)) {
7629 fail(runString);
7630 return;
7631 }
7632 // (1000000000000) == 1000000000000
7633 runString = "(1000000000000)";
7634 if (1000000000000L != jtt.bytecode.BC_lreturn.test(1000000000000L)) {
7635 fail(runString);
7636 return;
7637 }
7638 } catch (Throwable t) {
7639 fail(runString, t);
7640 return;
7641 }
7642 pass();
7643 }
7644
7645 static void jtt_bytecode_BC_lshl() {
7646 begin("jtt.bytecode.BC_lshl");
7647 String runString = null;
7648 try {
7649 // (1,2) == 4
7650 runString = "(1,2)";
7651 if (4L != jtt.bytecode.BC_lshl.test(1L, 2)) {
7652 fail(runString);
7653 return;
7654 }
7655 // (0,-1) == 0
7656 runString = "(0,-1)";
7657 if (0L != jtt.bytecode.BC_lshl.test(0L, -1)) {
7658 fail(runString);
7659 return;
7660 }
7661 // (31,1) == 62
7662 runString = "(31,1)";
7663 if (62L != jtt.bytecode.BC_lshl.test(31L, 1)) {
7664 fail(runString);
7665 return;
7666 }
7667 // (6,4) == 96
7668 runString = "(6,4)";
7669 if (96L != jtt.bytecode.BC_lshl.test(6L, 4)) {
7670 fail(runString);
7671 return;
7672 }
7673 // (-2147483648,1) == -4294967296
7674 runString = "(-2147483648,1)";
7675 if (-4294967296L != jtt.bytecode.BC_lshl.test(-2147483648L, 1)) {
7676 fail(runString);
7677 return;
7678 }
7679 } catch (Throwable t) {
7680 fail(runString, t);
7681 return;
7682 }
7683 pass();
7684 }
7685
7686 static void jtt_bytecode_BC_lshr() {
7687 begin("jtt.bytecode.BC_lshr");
7688 String runString = null;
7689 try {
7690 // (1,2) == 0
7691 runString = "(1,2)";
7692 if (0L != jtt.bytecode.BC_lshr.test(1L, 2)) {
7693 fail(runString);
7694 return;
7695 }
7696 // (67,2) == 16
7697 runString = "(67,2)";
7698 if (16L != jtt.bytecode.BC_lshr.test(67L, 2)) {
7699 fail(runString);
7700 return;
7701 }
7702 // (31,1) == 15
7703 runString = "(31,1)";
7704 if (15L != jtt.bytecode.BC_lshr.test(31L, 1)) {
7705 fail(runString);
7706 return;
7707 }
7708 // (6,4) == 0
7709 runString = "(6,4)";
7710 if (0L != jtt.bytecode.BC_lshr.test(6L, 4)) {
7711 fail(runString);
7712 return;
7713 }
7714 // (-2147483648,16) == -32768
7715 runString = "(-2147483648,16)";
7716 if (-32768L != jtt.bytecode.BC_lshr.test(-2147483648L, 16)) {
7717 fail(runString);
7718 return;
7719 }
7720 } catch (Throwable t) {
7721 fail(runString, t);
7722 return;
7723 }
7724 pass();
7725 }
7726
7727 static void jtt_bytecode_BC_lsub() {
7728 begin("jtt.bytecode.BC_lsub");
7729 String runString = null;
7730 try {
7731 // (1,-2) == 3
7732 runString = "(1,-2)";
7733 if (3L != jtt.bytecode.BC_lsub.test(1L, -2L)) {
7734 fail(runString);
7735 return;
7736 }
7737 // (0,1) == -1
7738 runString = "(0,1)";
7739 if (-1L != jtt.bytecode.BC_lsub.test(0L, 1L)) {
7740 fail(runString);
7741 return;
7742 }
7743 // (33,-67) == 100
7744 runString = "(33,-67)";
7745 if (100L != jtt.bytecode.BC_lsub.test(33L, -67L)) {
7746 fail(runString);
7747 return;
7748 }
7749 // (1,1) == 0
7750 runString = "(1,1)";
7751 if (0L != jtt.bytecode.BC_lsub.test(1L, 1L)) {
7752 fail(runString);
7753 return;
7754 }
7755 // (-2147483648,-1) == -2147483647
7756 runString = "(-2147483648,-1)";
7757 if (-2147483647L != jtt.bytecode.BC_lsub.test(-2147483648L, -1L)) {
7758 fail(runString);
7759 return;
7760 }
7761 // (2147483647,-1) == 2147483648
7762 runString = "(2147483647,-1)";
7763 if (2147483648L != jtt.bytecode.BC_lsub.test(2147483647L, -1L)) {
7764 fail(runString);
7765 return;
7766 }
7767 } catch (Throwable t) {
7768 fail(runString, t);
7769 return;
7770 }
7771 pass();
7772 }
7773
7774 static void jtt_bytecode_BC_lushr() {
7775 begin("jtt.bytecode.BC_lushr");
7776 String runString = null;
7777 try {
7778 // (1,2) == 0
7779 runString = "(1,2)";
7780 if (0L != jtt.bytecode.BC_lushr.test(1L, 2)) {
7781 fail(runString);
7782 return;
7783 }
7784 // (67,2) == 16
7785 runString = "(67,2)";
7786 if (16L != jtt.bytecode.BC_lushr.test(67L, 2)) {
7787 fail(runString);
7788 return;
7789 }
7790 // (31,1) == 15
7791 runString = "(31,1)";
7792 if (15L != jtt.bytecode.BC_lushr.test(31L, 1)) {
7793 fail(runString);
7794 return;
7795 }
7796 // (6,4) == 0
7797 runString = "(6,4)";
7798 if (0L != jtt.bytecode.BC_lushr.test(6L, 4)) {
7799 fail(runString);
7800 return;
7801 }
7802 // (-2147483648,16) == 281474976677888
7803 runString = "(-2147483648,16)";
7804 if (281474976677888L != jtt.bytecode.BC_lushr
7805 .test(-2147483648L, 16)) {
7806 fail(runString);
7807 return;
7808 }
7809 } catch (Throwable t) {
7810 fail(runString, t);
7811 return;
7812 }
7813 pass();
7814 }
7815
7816 static void jtt_bytecode_BC_lxor() {
7817 begin("jtt.bytecode.BC_lxor");
7818 String runString = null;
7819 try {
7820 // (1,2) == 3
7821 runString = "(1,2)";
7822 if (3L != jtt.bytecode.BC_lxor.test(1L, 2L)) {
7823 fail(runString);
7824 return;
7825 }
7826 // (0,-1) == -1
7827 runString = "(0,-1)";
7828 if (-1L != jtt.bytecode.BC_lxor.test(0L, -1L)) {
7829 fail(runString);
7830 return;
7831 }
7832 // (31,63) == 32
7833 runString = "(31,63)";
7834 if (32L != jtt.bytecode.BC_lxor.test(31L, 63L)) {
7835 fail(runString);
7836 return;
7837 }
7838 // (6,4) == 2
7839 runString = "(6,4)";
7840 if (2L != jtt.bytecode.BC_lxor.test(6L, 4L)) {
7841 fail(runString);
7842 return;
7843 }
7844 // (-2147483648,1) == -2147483647
7845 runString = "(-2147483648,1)";
7846 if (-2147483647L != jtt.bytecode.BC_lxor.test(-2147483648L, 1L)) {
7847 fail(runString);
7848 return;
7849 }
7850 } catch (Throwable t) {
7851 fail(runString, t);
7852 return;
7853 }
7854 pass();
7855 }
7856
7857 static void jtt_bytecode_BC_monitorenter() {
7858 begin("jtt.bytecode.BC_monitorenter");
7859 String runString = null;
7860 try {
7861 // (0) == 0
7862 runString = "(0)";
7863 if (0 != jtt.bytecode.BC_monitorenter.test(0)) {
7864 fail(runString);
7865 return;
7866 }
7867 // (1) == 1
7868 runString = "(1)";
7869 if (1 != jtt.bytecode.BC_monitorenter.test(1)) {
7870 fail(runString);
7871 return;
7872 }
7873 // (-2) == -2
7874 runString = "(-2)";
7875 if (-2 != jtt.bytecode.BC_monitorenter.test(-2)) {
7876 fail(runString);
7877 return;
7878 }
7879 } catch (Throwable t) {
7880 fail(runString, t);
7881 return;
7882 }
7883 pass();
7884 }
7885
7886 static void jtt_bytecode_BC_monitorenter02() {
7887 begin("jtt.bytecode.BC_monitorenter02");
7888 String runString = null;
7889 try {
7890 // (0,1) == 0
7891 runString = "(0,1)";
7892 if (0 != jtt.bytecode.BC_monitorenter02.test(0, 1)) {
7893 fail(runString);
7894 return;
7895 }
7896 // (1,1) == 1
7897 runString = "(1,1)";
7898 if (1 != jtt.bytecode.BC_monitorenter02.test(1, 1)) {
7899 fail(runString);
7900 return;
7901 }
7902 // (-2,1) == -2
7903 runString = "(-2,1)";
7904 if (-2 != jtt.bytecode.BC_monitorenter02.test(-2, 1)) {
7905 fail(runString);
7906 return;
7907 }
7908 } catch (Throwable t) {
7909 fail(runString, t);
7910 return;
7911 }
7912 pass();
7913 }
7914
7915 static void jtt_bytecode_BC_multianewarray01() {
7916 begin("jtt.bytecode.BC_multianewarray01");
7917 String runString = null;
7918 try {
7919 // (0) == 0
7920 runString = "(0)";
7921 if (0 != jtt.bytecode.BC_multianewarray01.test(0)) {
7922 fail(runString);
7923 return;
7924 }
7925 // (1) == 1
7926 runString = "(1)";
7927 if (1 != jtt.bytecode.BC_multianewarray01.test(1)) {
7928 fail(runString);
7929 return;
7930 }
7931 } catch (Throwable t) {
7932 fail(runString, t);
7933 return;
7934 }
7935 pass();
7936 }
7937
7938 static void jtt_bytecode_BC_multianewarray02() {
7939 begin("jtt.bytecode.BC_multianewarray02");
7940 String runString = null;
7941 try {
7942 // (0) == 0
7943 runString = "(0)";
7944 if (0 != jtt.bytecode.BC_multianewarray02.test(0)) {
7945 fail(runString);
7946 return;
7947 }
7948 // (1) == 1
7949 runString = "(1)";
7950 if (1 != jtt.bytecode.BC_multianewarray02.test(1)) {
7951 fail(runString);
7952 return;
7953 }
7954 } catch (Throwable t) {
7955 fail(runString, t);
7956 return;
7957 }
7958 pass();
7959 }
7960
7961 static void jtt_bytecode_BC_multianewarray03() {
7962 begin("jtt.bytecode.BC_multianewarray03");
7963 String runString = null;
7964 try {
7965 // (1) == 4
7966 runString = "(1)";
7967 if (4 != jtt.bytecode.BC_multianewarray03.test(1)) {
7968 fail(runString);
7969 return;
7970 }
7971 // (2) == 8
7972 runString = "(2)";
7973 if (8 != jtt.bytecode.BC_multianewarray03.test(2)) {
7974 fail(runString);
7975 return;
7976 }
7977 // (3) == 12
7978 runString = "(3)";
7979 if (12 != jtt.bytecode.BC_multianewarray03.test(3)) {
7980 fail(runString);
7981 return;
7982 }
7983 } catch (Throwable t) {
7984 fail(runString, t);
7985 return;
7986 }
7987 pass();
7988 }
7989
7990 static void jtt_bytecode_BC_multianewarray04() {
7991 begin("jtt.bytecode.BC_multianewarray04");
7992 String runString = null;
7993 try {
7994 // (1) == 41
7995 runString = "(1)";
7996 if (41 != jtt.bytecode.BC_multianewarray04.test(1)) {
7997 fail(runString);
7998 return;
7999 }
8000 // (2) == 81
8001 runString = "(2)";
8002 if (81 != jtt.bytecode.BC_multianewarray04.test(2)) {
8003 fail(runString);
8004 return;
8005 }
8006 } catch (Throwable t) {
8007 fail(runString, t);
8008 return;
8009 }
8010 pass();
8011 }
8012
8013 static void jtt_bytecode_BC_new() {
8014 begin("jtt.bytecode.BC_new");
8015 String runString = null;
8016 try {
8017 // (0) == 0
8018 runString = "(0)";
8019 if (0 != jtt.bytecode.BC_new.test(0)) {
8020 fail(runString);
8021 return;
8022 }
8023 } catch (Throwable t) {
8024 fail(runString, t);
8025 return;
8026 }
8027 pass();
8028 }
8029
8030 static void jtt_bytecode_BC_newarray() {
8031 begin("jtt.bytecode.BC_newarray");
8032 String runString = null;
8033 try {
8034 // (0) == 0
8035 runString = "(0)";
8036 if (0 != jtt.bytecode.BC_newarray.test(0)) {
8037 fail(runString);
8038 return;
8039 }
8040 // (1) == 1
8041 runString = "(1)";
8042 if (1 != jtt.bytecode.BC_newarray.test(1)) {
8043 fail(runString);
8044 return;
8045 }
8046 } catch (Throwable t) {
8047 fail(runString, t);
8048 return;
8049 }
8050 pass();
8051 }
8052
8053 static void jtt_bytecode_BC_putfield() {
8054 begin("jtt.bytecode.BC_putfield");
8055 String runString = null;
8056 try {
8057 // (0) == 0
8058 runString = "(0)";
8059 if (0 != jtt.bytecode.BC_putfield.test(0)) {
8060 fail(runString);
8061 return;
8062 }
8063 // (1) == 1
8064 runString = "(1)";
8065 if (1 != jtt.bytecode.BC_putfield.test(1)) {
8066 fail(runString);
8067 return;
8068 }
8069 // (2) == 2
8070 runString = "(2)";
8071 if (2 != jtt.bytecode.BC_putfield.test(2)) {
8072 fail(runString);
8073 return;
8074 }
8075 // (-4) == -4
8076 runString = "(-4)";
8077 if (-4 != jtt.bytecode.BC_putfield.test(-4)) {
8078 fail(runString);
8079 return;
8080 }
8081 } catch (Throwable t) {
8082 fail(runString, t);
8083 return;
8084 }
8085 pass();
8086 }
8087
8088 static void jtt_bytecode_BC_putstatic() {
8089 begin("jtt.bytecode.BC_putstatic");
8090 String runString = null;
8091 try {
8092 // (0) == 0
8093 runString = "(0)";
8094 if (0 != jtt.bytecode.BC_putstatic.test(0)) {
8095 fail(runString);
8096 return;
8097 }
8098 // (1) == 1
8099 runString = "(1)";
8100 if (1 != jtt.bytecode.BC_putstatic.test(1)) {
8101 fail(runString);
8102 return;
8103 }
8104 // (2) == 2
8105 runString = "(2)";
8106 if (2 != jtt.bytecode.BC_putstatic.test(2)) {
8107 fail(runString);
8108 return;
8109 }
8110 // (3) == 3
8111 runString = "(3)";
8112 if (3 != jtt.bytecode.BC_putstatic.test(3)) {
8113 fail(runString);
8114 return;
8115 }
8116 // (-4) == -4
8117 runString = "(-4)";
8118 if (-4 != jtt.bytecode.BC_putstatic.test(-4)) {
8119 fail(runString);
8120 return;
8121 }
8122 } catch (Throwable t) {
8123 fail(runString, t);
8124 return;
8125 }
8126 pass();
8127 }
8128
8129 static void jtt_bytecode_BC_saload() {
8130 begin("jtt.bytecode.BC_saload");
8131 String runString = null;
8132 try {
8133 // (0) == 0
8134 runString = "(0)";
8135 if ((short) 0 != jtt.bytecode.BC_saload.test(0)) {
8136 fail(runString);
8137 return;
8138 }
8139 // (1) == -1
8140 runString = "(1)";
8141 if ((short) -1 != jtt.bytecode.BC_saload.test(1)) {
8142 fail(runString);
8143 return;
8144 }
8145 // (2) == 4
8146 runString = "(2)";
8147 if ((short) 4 != jtt.bytecode.BC_saload.test(2)) {
8148 fail(runString);
8149 return;
8150 }
8151 // (3) == 10000
8152 runString = "(3)";
8153 if ((short) 10000 != jtt.bytecode.BC_saload.test(3)) {
8154 fail(runString);
8155 return;
8156 }
8157 } catch (Throwable t) {
8158 fail(runString, t);
8159 return;
8160 }
8161 pass();
8162 }
8163
8164 static void jtt_bytecode_BC_sastore() {
8165 begin("jtt.bytecode.BC_sastore");
8166 String runString = null;
8167 try {
8168 // (0,0) == 0
8169 runString = "(0,0)";
8170 if ((short) 0 != jtt.bytecode.BC_sastore.test(0, (short) 0)) {
8171 fail(runString);
8172 return;
8173 }
8174 // (1,-1) == -1
8175 runString = "(1,-1)";
8176 if ((short) -1 != jtt.bytecode.BC_sastore.test(1, (short) -1)) {
8177 fail(runString);
8178 return;
8179 }
8180 // (2,11) == 11
8181 runString = "(2,11)";
8182 if ((short) 11 != jtt.bytecode.BC_sastore.test(2, (short) 11)) {
8183 fail(runString);
8184 return;
8185 }
8186 // (3,-14) == -14
8187 runString = "(3,-14)";
8188 if ((short) -14 != jtt.bytecode.BC_sastore.test(3, (short) -14)) {
8189 fail(runString);
8190 return;
8191 }
8192 } catch (Throwable t) {
8193 fail(runString, t);
8194 return;
8195 }
8196 pass();
8197 }
8198
8199 static void jtt_bytecode_BC_tableswitch() {
8200 begin("jtt.bytecode.BC_tableswitch");
8201 String runString = null;
8202 try {
8203 // (-1) == 42
8204 runString = "(-1)";
8205 if (42 != jtt.bytecode.BC_tableswitch.test(-1)) {
8206 fail(runString);
8207 return;
8208 }
8209 // (0) == 10
8210 runString = "(0)";
8211 if (10 != jtt.bytecode.BC_tableswitch.test(0)) {
8212 fail(runString);
8213 return;
8214 }
8215 // (1) == 20
8216 runString = "(1)";
8217 if (20 != jtt.bytecode.BC_tableswitch.test(1)) {
8218 fail(runString);
8219 return;
8220 }
8221 // (2) == 30
8222 runString = "(2)";
8223 if (30 != jtt.bytecode.BC_tableswitch.test(2)) {
8224 fail(runString);
8225 return;
8226 }
8227 // (3) == 42
8228 runString = "(3)";
8229 if (42 != jtt.bytecode.BC_tableswitch.test(3)) {
8230 fail(runString);
8231 return;
8232 }
8233 // (4) == 40
8234 runString = "(4)";
8235 if (40 != jtt.bytecode.BC_tableswitch.test(4)) {
8236 fail(runString);
8237 return;
8238 }
8239 // (5) == 50
8240 runString = "(5)";
8241 if (50 != jtt.bytecode.BC_tableswitch.test(5)) {
8242 fail(runString);
8243 return;
8244 }
8245 // (6) == 42
8246 runString = "(6)";
8247 if (42 != jtt.bytecode.BC_tableswitch.test(6)) {
8248 fail(runString);
8249 return;
8250 }
8251 } catch (Throwable t) {
8252 fail(runString, t);
8253 return;
8254 }
8255 pass();
8256 }
8257
8258 static void jtt_bytecode_BC_tableswitch2() {
8259 begin("jtt.bytecode.BC_tableswitch2");
8260 String runString = null;
8261 try {
8262 // (-1) == 11
8263 runString = "(-1)";
8264 if (11 != jtt.bytecode.BC_tableswitch2.test(-1)) {
8265 fail(runString);
8266 return;
8267 }
8268 // (0) == 11
8269 runString = "(0)";
8270 if (11 != jtt.bytecode.BC_tableswitch2.test(0)) {
8271 fail(runString);
8272 return;
8273 }
8274 // (1) == 11
8275 runString = "(1)";
8276 if (11 != jtt.bytecode.BC_tableswitch2.test(1)) {
8277 fail(runString);
8278 return;
8279 }
8280 // (5) == 55
8281 runString = "(5)";
8282 if (55 != jtt.bytecode.BC_tableswitch2.test(5)) {
8283 fail(runString);
8284 return;
8285 }
8286 // (6) == 66
8287 runString = "(6)";
8288 if (66 != jtt.bytecode.BC_tableswitch2.test(6)) {
8289 fail(runString);
8290 return;
8291 }
8292 // (7) == 77
8293 runString = "(7)";
8294 if (77 != jtt.bytecode.BC_tableswitch2.test(7)) {
8295 fail(runString);
8296 return;
8297 }
8298 // (8) == 11
8299 runString = "(8)";
8300 if (11 != jtt.bytecode.BC_tableswitch2.test(8)) {
8301 fail(runString);
8302 return;
8303 }
8304 } catch (Throwable t) {
8305 fail(runString, t);
8306 return;
8307 }
8308 pass();
8309 }
8310
8311 static void jtt_bytecode_BC_tableswitch3() {
8312 begin("jtt.bytecode.BC_tableswitch3");
8313 String runString = null;
8314 try {
8315 // (-1) == 11
8316 runString = "(-1)";
8317 if (11 != jtt.bytecode.BC_tableswitch3.test(-1)) {
8318 fail(runString);
8319 return;
8320 }
8321 // (-2) == 22
8322 runString = "(-2)";
8323 if (22 != jtt.bytecode.BC_tableswitch3.test(-2)) {
8324 fail(runString);
8325 return;
8326 }
8327 // (-3) == 99
8328 runString = "(-3)";
8329 if (99 != jtt.bytecode.BC_tableswitch3.test(-3)) {
8330 fail(runString);
8331 return;
8332 }
8333 // (-4) == 99
8334 runString = "(-4)";
8335 if (99 != jtt.bytecode.BC_tableswitch3.test(-4)) {
8336 fail(runString);
8337 return;
8338 }
8339 // (1) == 77
8340 runString = "(1)";
8341 if (77 != jtt.bytecode.BC_tableswitch3.test(1)) {
8342 fail(runString);
8343 return;
8344 }
8345 // (2) == 99
8346 runString = "(2)";
8347 if (99 != jtt.bytecode.BC_tableswitch3.test(2)) {
8348 fail(runString);
8349 return;
8350 }
8351 // (10) == 99
8352 runString = "(10)";
8353 if (99 != jtt.bytecode.BC_tableswitch3.test(10)) {
8354 fail(runString);
8355 return;
8356 }
8357 } catch (Throwable t) {
8358 fail(runString, t);
8359 return;
8360 }
8361 pass();
8362 }
8363
8364 static void jtt_bytecode_BC_tableswitch4() {
8365 begin("jtt.bytecode.BC_tableswitch4");
8366 String runString = null;
8367 try {
8368 // (-1) == 11
8369 runString = "(-1)";
8370 if (11 != jtt.bytecode.BC_tableswitch4.test(-1)) {
8371 fail(runString);
8372 return;
8373 }
8374 // (0) == 11
8375 runString = "(0)";
8376 if (11 != jtt.bytecode.BC_tableswitch4.test(0)) {
8377 fail(runString);
8378 return;
8379 }
8380 // (1) == 11
8381 runString = "(1)";
8382 if (11 != jtt.bytecode.BC_tableswitch4.test(1)) {
8383 fail(runString);
8384 return;
8385 }
8386 // (-5) == 55
8387 runString = "(-5)";
8388 if (55 != jtt.bytecode.BC_tableswitch4.test(-5)) {
8389 fail(runString);
8390 return;
8391 }
8392 // (-4) == 44
8393 runString = "(-4)";
8394 if (44 != jtt.bytecode.BC_tableswitch4.test(-4)) {
8395 fail(runString);
8396 return;
8397 }
8398 // (-3) == 33
8399 runString = "(-3)";
8400 if (33 != jtt.bytecode.BC_tableswitch4.test(-3)) {
8401 fail(runString);
8402 return;
8403 }
8404 // (-8) == 11
8405 runString = "(-8)";
8406 if (11 != jtt.bytecode.BC_tableswitch4.test(-8)) {
8407 fail(runString);
8408 return;
8409 }
8410 } catch (Throwable t) {
8411 fail(runString, t);
8412 return;
8413 }
8414 pass();
8415 }
8416
8417 static void jtt_bytecode_BC_wide01() {
8418 begin("jtt.bytecode.BC_wide01");
8419 String runString = null;
8420 try {
8421 // (0) == 11
8422 runString = "(0)";
8423 if (11 != jtt.bytecode.BC_wide01.test(0)) {
8424 fail(runString);
8425 return;
8426 }
8427 // (1) == 12
8428 runString = "(1)";
8429 if (12 != jtt.bytecode.BC_wide01.test(1)) {
8430 fail(runString);
8431 return;
8432 }
8433 } catch (Throwable t) {
8434 fail(runString, t);
8435 return;
8436 }
8437 pass();
8438 }
8439
8440 static void jtt_bytecode_BC_wide02() {
8441 begin("jtt.bytecode.BC_wide02");
8442 String runString = null;
8443 try {
8444 // (0) == 11
8445 runString = "(0)";
8446 if (11 != jtt.bytecode.BC_wide02.test(0)) {
8447 fail(runString);
8448 return;
8449 }
8450 // (1) == 12
8451 runString = "(1)";
8452 if (12 != jtt.bytecode.BC_wide02.test(1)) {
8453 fail(runString);
8454 return;
8455 }
8456 } catch (Throwable t) {
8457 fail(runString, t);
8458 return;
8459 }
8460 pass();
8461 }
8462
8463 static void jtt_optimize_ArrayLength01() {
8464 begin("jtt.optimize.ArrayLength01");
8465 String runString = null;
8466 try {
8467 // (0) == 5
8468 runString = "(0)";
8469 if (5 != jtt.optimize.ArrayLength01.test(0)) {
8470 fail(runString);
8471 return;
8472 }
8473 // (1) == 6
8474 runString = "(1)";
8475 if (6 != jtt.optimize.ArrayLength01.test(1)) {
8476 fail(runString);
8477 return;
8478 }
8479 // (2) == 7
8480 runString = "(2)";
8481 if (7 != jtt.optimize.ArrayLength01.test(2)) {
8482 fail(runString);
8483 return;
8484 }
8485 // (3) == 8
8486 runString = "(3)";
8487 if (8 != jtt.optimize.ArrayLength01.test(3)) {
8488 fail(runString);
8489 return;
8490 }
8491 // (4) == 4
8492 runString = "(4)";
8493 if (4 != jtt.optimize.ArrayLength01.test(4)) {
8494 fail(runString);
8495 return;
8496 }
8497 } catch (Throwable t) {
8498 fail(runString, t);
8499 return;
8500 }
8501 pass();
8502 }
8503
8504 static void jtt_optimize_BC_idiv_16() {
8505 begin("jtt.optimize.BC_idiv_16");
8506 String runString = null;
8507 try {
8508 // (0,0) == 0
8509 runString = "(0,0)";
8510 if (0 != jtt.optimize.BC_idiv_16.test(0, 0)) {
8511 fail(runString);
8512 return;
8513 }
8514 // (0,16) == 1
8515 runString = "(0,16)";
8516 if (1 != jtt.optimize.BC_idiv_16.test(0, 16)) {
8517 fail(runString);
8518 return;
8519 }
8520 // (0,17) == 1
8521 runString = "(0,17)";
8522 if (1 != jtt.optimize.BC_idiv_16.test(0, 17)) {
8523 fail(runString);
8524 return;
8525 }
8526 // (0,-1) == 0
8527 runString = "(0,-1)";
8528 if (0 != jtt.optimize.BC_idiv_16.test(0, -1)) {
8529 fail(runString);
8530 return;
8531 }
8532 // (0,-16) == -1
8533 runString = "(0,-16)";
8534 if (-1 != jtt.optimize.BC_idiv_16.test(0, -16)) {
8535 fail(runString);
8536 return;
8537 }
8538 // (0,-17) == -1
8539 runString = "(0,-17)";
8540 if (-1 != jtt.optimize.BC_idiv_16.test(0, -17)) {
8541 fail(runString);
8542 return;
8543 }
8544 // (0,-1024) == -64
8545 runString = "(0,-1024)";
8546 if (-64 != jtt.optimize.BC_idiv_16.test(0, -1024)) {
8547 fail(runString);
8548 return;
8549 }
8550 // (1,0) == 0
8551 runString = "(1,0)";
8552 if (0 != jtt.optimize.BC_idiv_16.test(1, 0)) {
8553 fail(runString);
8554 return;
8555 }
8556 // (1,16) == 1
8557 runString = "(1,16)";
8558 if (1 != jtt.optimize.BC_idiv_16.test(1, 16)) {
8559 fail(runString);
8560 return;
8561 }
8562 // (1,17) == 1
8563 runString = "(1,17)";
8564 if (1 != jtt.optimize.BC_idiv_16.test(1, 17)) {
8565 fail(runString);
8566 return;
8567 }
8568 // (1,-1) == 0
8569 runString = "(1,-1)";
8570 if (0 != jtt.optimize.BC_idiv_16.test(1, -1)) {
8571 fail(runString);
8572 return;
8573 }
8574 // (1,-16) == -1
8575 runString = "(1,-16)";
8576 if (-1 != jtt.optimize.BC_idiv_16.test(1, -16)) {
8577 fail(runString);
8578 return;
8579 }
8580 // (1,-17) == -1
8581 runString = "(1,-17)";
8582 if (-1 != jtt.optimize.BC_idiv_16.test(1, -17)) {
8583 fail(runString);
8584 return;
8585 }
8586 // (1,-1024) == -64
8587 runString = "(1,-1024)";
8588 if (-64 != jtt.optimize.BC_idiv_16.test(1, -1024)) {
8589 fail(runString);
8590 return;
8591 }
8592 } catch (Throwable t) {
8593 fail(runString, t);
8594 return;
8595 }
8596 pass();
8597 }
8598
8599 static void jtt_optimize_BC_idiv_4() {
8600 begin("jtt.optimize.BC_idiv_4");
8601 String runString = null;
8602 try {
8603 // (0) == 0
8604 runString = "(0)";
8605 if (0 != jtt.optimize.BC_idiv_4.test(0)) {
8606 fail(runString);
8607 return;
8608 }
8609 // (4) == 1
8610 runString = "(4)";
8611 if (1 != jtt.optimize.BC_idiv_4.test(4)) {
8612 fail(runString);
8613 return;
8614 }
8615 // (5) == 1
8616 runString = "(5)";
8617 if (1 != jtt.optimize.BC_idiv_4.test(5)) {
8618 fail(runString);
8619 return;
8620 }
8621 // (-1) == 0
8622 runString = "(-1)";
8623 if (0 != jtt.optimize.BC_idiv_4.test(-1)) {
8624 fail(runString);
8625 return;
8626 }
8627 // (-4) == -1
8628 runString = "(-4)";
8629 if (-1 != jtt.optimize.BC_idiv_4.test(-4)) {
8630 fail(runString);
8631 return;
8632 }
8633 // (-5) == -1
8634 runString = "(-5)";
8635 if (-1 != jtt.optimize.BC_idiv_4.test(-5)) {
8636 fail(runString);
8637 return;
8638 }
8639 // (-256) == -64
8640 runString = "(-256)";
8641 if (-64 != jtt.optimize.BC_idiv_4.test(-256)) {
8642 fail(runString);
8643 return;
8644 }
8645 } catch (Throwable t) {
8646 fail(runString, t);
8647 return;
8648 }
8649 pass();
8650 }
8651
8652 static void jtt_optimize_BC_imul_16() {
8653 begin("jtt.optimize.BC_imul_16");
8654 String runString = null;
8655 try {
8656 // (0,0) == 0
8657 runString = "(0,0)";
8658 if (0 != jtt.optimize.BC_imul_16.test(0, 0)) {
8659 fail(runString);
8660 return;
8661 }
8662 // (0,16) == 256
8663 runString = "(0,16)";
8664 if (256 != jtt.optimize.BC_imul_16.test(0, 16)) {
8665 fail(runString);
8666 return;
8667 }
8668 // (0,17) == 272
8669 runString = "(0,17)";
8670 if (272 != jtt.optimize.BC_imul_16.test(0, 17)) {
8671 fail(runString);
8672 return;
8673 }
8674 // (0,-1) == -16
8675 runString = "(0,-1)";
8676 if (-16 != jtt.optimize.BC_imul_16.test(0, -1)) {
8677 fail(runString);
8678 return;
8679 }
8680 // (0,-16) == -256
8681 runString = "(0,-16)";
8682 if (-256 != jtt.optimize.BC_imul_16.test(0, -16)) {
8683 fail(runString);
8684 return;
8685 }
8686 // (0,-17) == -272
8687 runString = "(0,-17)";
8688 if (-272 != jtt.optimize.BC_imul_16.test(0, -17)) {
8689 fail(runString);
8690 return;
8691 }
8692 // (0,2147483647) == -16
8693 runString = "(0,2147483647)";
8694 if (-16 != jtt.optimize.BC_imul_16.test(0, 2147483647)) {
8695 fail(runString);
8696 return;
8697 }
8698 // (0,-2147483648) == 0
8699 runString = "(0,-2147483648)";
8700 if (0 != jtt.optimize.BC_imul_16.test(0, -2147483648)) {
8701 fail(runString);
8702 return;
8703 }
8704 // (1,0) == 0
8705 runString = "(1,0)";
8706 if (0 != jtt.optimize.BC_imul_16.test(1, 0)) {
8707 fail(runString);
8708 return;
8709 }
8710 // (1,16) == 256
8711 runString = "(1,16)";
8712 if (256 != jtt.optimize.BC_imul_16.test(1, 16)) {
8713 fail(runString);
8714 return;
8715 }
8716 // (1,17) == 272
8717 runString = "(1,17)";
8718 if (272 != jtt.optimize.BC_imul_16.test(1, 17)) {
8719 fail(runString);
8720 return;
8721 }
8722 // (1,-1) == -16
8723 runString = "(1,-1)";
8724 if (-16 != jtt.optimize.BC_imul_16.test(1, -1)) {
8725 fail(runString);
8726 return;
8727 }
8728 // (1,-16) == -256
8729 runString = "(1,-16)";
8730 if (-256 != jtt.optimize.BC_imul_16.test(1, -16)) {
8731 fail(runString);
8732 return;
8733 }
8734 // (1,-17) == -272
8735 runString = "(1,-17)";
8736 if (-272 != jtt.optimize.BC_imul_16.test(1, -17)) {
8737 fail(runString);
8738 return;
8739 }
8740 // (1,2147483647) == -16
8741 runString = "(1,2147483647)";
8742 if (-16 != jtt.optimize.BC_imul_16.test(1, 2147483647)) {
8743 fail(runString);
8744 return;
8745 }
8746 // (1,-2147483648) == 0
8747 runString = "(1,-2147483648)";
8748 if (0 != jtt.optimize.BC_imul_16.test(1, -2147483648)) {
8749 fail(runString);
8750 return;
8751 }
8752 } catch (Throwable t) {
8753 fail(runString, t);
8754 return;
8755 }
8756 pass();
8757 }
8758
8759 static void jtt_optimize_BC_imul_4() {
8760 begin("jtt.optimize.BC_imul_4");
8761 String runString = null;
8762 try {
8763 // (0) == 0
8764 runString = "(0)";
8765 if (0 != jtt.optimize.BC_imul_4.test(0)) {
8766 fail(runString);
8767 return;
8768 }
8769 // (4) == 16
8770 runString = "(4)";
8771 if (16 != jtt.optimize.BC_imul_4.test(4)) {
8772 fail(runString);
8773 return;
8774 }
8775 // (5) == 20
8776 runString = "(5)";
8777 if (20 != jtt.optimize.BC_imul_4.test(5)) {
8778 fail(runString);
8779 return;
8780 }
8781 // (-1) == -4
8782 runString = "(-1)";
8783 if (-4 != jtt.optimize.BC_imul_4.test(-1)) {
8784 fail(runString);
8785 return;
8786 }
8787 // (-4) == -16
8788 runString = "(-4)";
8789 if (-16 != jtt.optimize.BC_imul_4.test(-4)) {
8790 fail(runString);
8791 return;
8792 }
8793 // (-5) == -20
8794 runString = "(-5)";
8795 if (-20 != jtt.optimize.BC_imul_4.test(-5)) {
8796 fail(runString);
8797 return;
8798 }
8799 // (-256) == -1024
8800 runString = "(-256)";
8801 if (-1024 != jtt.optimize.BC_imul_4.test(-256)) {
8802 fail(runString);
8803 return;
8804 }
8805 } catch (Throwable t) {
8806 fail(runString, t);
8807 return;
8808 }
8809 pass();
8810 }
8811
8812 static void jtt_optimize_BC_ldiv_16() {
8813 begin("jtt.optimize.BC_ldiv_16");
8814 String runString = null;
8815 try {
8816 // (0) == 0
8817 runString = "(0)";
8818 if (0L != jtt.optimize.BC_ldiv_16.test(0L)) {
8819 fail(runString);
8820 return;
8821 }
8822 // (16) == 1
8823 runString = "(16)";
8824 if (1L != jtt.optimize.BC_ldiv_16.test(16L)) {
8825 fail(runString);
8826 return;
8827 }
8828 // (17) == 1
8829 runString = "(17)";
8830 if (1L != jtt.optimize.BC_ldiv_16.test(17L)) {
8831 fail(runString);
8832 return;
8833 }
8834 // (-1) == 0
8835 runString = "(-1)";
8836 if (0L != jtt.optimize.BC_ldiv_16.test(-1L)) {
8837 fail(runString);
8838 return;
8839 }
8840 // (-16) == -1
8841 runString = "(-16)";
8842 if (-1L != jtt.optimize.BC_ldiv_16.test(-16L)) {
8843 fail(runString);
8844 return;
8845 }
8846 // (-17) == -1
8847 runString = "(-17)";
8848 if (-1L != jtt.optimize.BC_ldiv_16.test(-17L)) {
8849 fail(runString);
8850 return;
8851 }
8852 // (-1024) == -64
8853 runString = "(-1024)";
8854 if (-64L != jtt.optimize.BC_ldiv_16.test(-1024L)) {
8855 fail(runString);
8856 return;
8857 }
8858 } catch (Throwable t) {
8859 fail(runString, t);
8860 return;
8861 }
8862 pass();
8863 }
8864
8865 static void jtt_optimize_BC_ldiv_4() {
8866 begin("jtt.optimize.BC_ldiv_4");
8867 String runString = null;
8868 try {
8869 // (0) == 0
8870 runString = "(0)";
8871 if (0L != jtt.optimize.BC_ldiv_4.test(0L)) {
8872 fail(runString);
8873 return;
8874 }
8875 // (4) == 1
8876 runString = "(4)";
8877 if (1L != jtt.optimize.BC_ldiv_4.test(4L)) {
8878 fail(runString);
8879 return;
8880 }
8881 // (5) == 1
8882 runString = "(5)";
8883 if (1L != jtt.optimize.BC_ldiv_4.test(5L)) {
8884 fail(runString);
8885 return;
8886 }
8887 // (-1) == 0
8888 runString = "(-1)";
8889 if (0L != jtt.optimize.BC_ldiv_4.test(-1L)) {
8890 fail(runString);
8891 return;
8892 }
8893 // (-4) == -1
8894 runString = "(-4)";
8895 if (-1L != jtt.optimize.BC_ldiv_4.test(-4L)) {
8896 fail(runString);
8897 return;
8898 }
8899 // (-5) == -1
8900 runString = "(-5)";
8901 if (-1L != jtt.optimize.BC_ldiv_4.test(-5L)) {
8902 fail(runString);
8903 return;
8904 }
8905 // (-256) == -64
8906 runString = "(-256)";
8907 if (-64L != jtt.optimize.BC_ldiv_4.test(-256L)) {
8908 fail(runString);
8909 return;
8910 }
8911 } catch (Throwable t) {
8912 fail(runString, t);
8913 return;
8914 }
8915 pass();
8916 }
8917
8918 static void jtt_optimize_BC_lmul_16() {
8919 begin("jtt.optimize.BC_lmul_16");
8920 String runString = null;
8921 try {
8922 // (0) == 0
8923 runString = "(0)";
8924 if (0L != jtt.optimize.BC_lmul_16.test(0L)) {
8925 fail(runString);
8926 return;
8927 }
8928 // (16) == 256
8929 runString = "(16)";
8930 if (256L != jtt.optimize.BC_lmul_16.test(16L)) {
8931 fail(runString);
8932 return;
8933 }
8934 // (17) == 272
8935 runString = "(17)";
8936 if (272L != jtt.optimize.BC_lmul_16.test(17L)) {
8937 fail(runString);
8938 return;
8939 }
8940 // (-1) == -16
8941 runString = "(-1)";
8942 if (-16L != jtt.optimize.BC_lmul_16.test(-1L)) {
8943 fail(runString);
8944 return;
8945 }
8946 // (-16) == -256
8947 runString = "(-16)";
8948 if (-256L != jtt.optimize.BC_lmul_16.test(-16L)) {
8949 fail(runString);
8950 return;
8951 }
8952 // (-17) == -272
8953 runString = "(-17)";
8954 if (-272L != jtt.optimize.BC_lmul_16.test(-17L)) {
8955 fail(runString);
8956 return;
8957 }
8958 // (-1024) == -16384
8959 runString = "(-1024)";
8960 if (-16384L != jtt.optimize.BC_lmul_16.test(-1024L)) {
8961 fail(runString);
8962 return;
8963 }
8964 } catch (Throwable t) {
8965 fail(runString, t);
8966 return;
8967 }
8968 pass();
8969 }
8970
8971 static void jtt_optimize_BC_lmul_4() {
8972 begin("jtt.optimize.BC_lmul_4");
8973 String runString = null;
8974 try {
8975 // (0) == 0
8976 runString = "(0)";
8977 if (0L != jtt.optimize.BC_lmul_4.test(0L)) {
8978 fail(runString);
8979 return;
8980 }
8981 // (4) == 16
8982 runString = "(4)";
8983 if (16L != jtt.optimize.BC_lmul_4.test(4L)) {
8984 fail(runString);
8985 return;
8986 }
8987 // (5) == 20
8988 runString = "(5)";
8989 if (20L != jtt.optimize.BC_lmul_4.test(5L)) {
8990 fail(runString);
8991 return;
8992 }
8993 // (-1) == -4
8994 runString = "(-1)";
8995 if (-4L != jtt.optimize.BC_lmul_4.test(-1L)) {
8996 fail(runString);
8997 return;
8998 }
8999 // (-4) == -16
9000 runString = "(-4)";
9001 if (-16L != jtt.optimize.BC_lmul_4.test(-4L)) {
9002 fail(runString);
9003 return;
9004 }
9005 // (-5) == -20
9006 runString = "(-5)";
9007 if (-20L != jtt.optimize.BC_lmul_4.test(-5L)) {
9008 fail(runString);
9009 return;
9010 }
9011 // (-256) == -1024
9012 runString = "(-256)";
9013 if (-1024L != jtt.optimize.BC_lmul_4.test(-256L)) {
9014 fail(runString);
9015 return;
9016 }
9017 } catch (Throwable t) {
9018 fail(runString, t);
9019 return;
9020 }
9021 pass();
9022 }
9023
9024 static void jtt_optimize_BC_lshr_C16() {
9025 begin("jtt.optimize.BC_lshr_C16");
9026 String runString = null;
9027 try {
9028 // (87224824140) == 1330945
9029 runString = "(87224824140)";
9030 if (1330945L != jtt.optimize.BC_lshr_C16.test(87224824140L)) {
9031 fail(runString);
9032 return;
9033 }
9034 } catch (Throwable t) {
9035 fail(runString, t);
9036 return;
9037 }
9038 pass();
9039 }
9040
9041 static void jtt_optimize_BC_lshr_C24() {
9042 begin("jtt.optimize.BC_lshr_C24");
9043 String runString = null;
9044 try {
9045 // (87224824140) == 5199
9046 runString = "(87224824140)";
9047 if (5199L != jtt.optimize.BC_lshr_C24.test(87224824140L)) {
9048 fail(runString);
9049 return;
9050 }
9051 } catch (Throwable t) {
9052 fail(runString, t);
9053 return;
9054 }
9055 pass();
9056 }
9057
9058 static void jtt_optimize_BC_lshr_C32() {
9059 begin("jtt.optimize.BC_lshr_C32");
9060 String runString = null;
9061 try {
9062 // (87224824140) == 20
9063 runString = "(87224824140)";
9064 if (20L != jtt.optimize.BC_lshr_C32.test(87224824140L)) {
9065 fail(runString);
9066 return;
9067 }
9068 } catch (Throwable t) {
9069 fail(runString, t);
9070 return;
9071 }
9072 pass();
9073 }
9074
9075 static void jtt_optimize_BlockSkip01() {
9076 begin("jtt.optimize.BlockSkip01");
9077 String runString = null;
9078 try {
9079 // (0) == true
9080 runString = "(0)";
9081 if (true != jtt.optimize.BlockSkip01.test(0)) {
9082 fail(runString);
9083 return;
9084 }
9085 // (1) == true
9086 runString = "(1)";
9087 if (true != jtt.optimize.BlockSkip01.test(1)) {
9088 fail(runString);
9089 return;
9090 }
9091 // (2) == true
9092 runString = "(2)";
9093 if (true != jtt.optimize.BlockSkip01.test(2)) {
9094 fail(runString);
9095 return;
9096 }
9097 // (3) == false
9098 runString = "(3)";
9099 if (false != jtt.optimize.BlockSkip01.test(3)) {
9100 fail(runString);
9101 return;
9102 }
9103 // (4) == false
9104 runString = "(4)";
9105 if (false != jtt.optimize.BlockSkip01.test(4)) {
9106 fail(runString);
9107 return;
9108 }
9109 } catch (Throwable t) {
9110 fail(runString, t);
9111 return;
9112 }
9113 pass();
9114 }
9115
9116 static void jtt_optimize_Cmov01() {
9117 begin("jtt.optimize.Cmov01");
9118 String runString = null;
9119 try {
9120 // (-1,-1) == true
9121 runString = "(-1,-1)";
9122 if (true != jtt.optimize.Cmov01.test(-1, -1)) {
9123 fail(runString);
9124 return;
9125 }
9126 // (1,10) == true
9127 runString = "(1,10)";
9128 if (true != jtt.optimize.Cmov01.test(1, 10)) {
9129 fail(runString);
9130 return;
9131 }
9132 // (1,0) == false
9133 runString = "(1,0)";
9134 if (false != jtt.optimize.Cmov01.test(1, 0)) {
9135 fail(runString);
9136 return;
9137 }
9138 } catch (Throwable t) {
9139 fail(runString, t);
9140 return;
9141 }
9142 pass();
9143 }
9144
9145 static void jtt_optimize_DeadCode01() {
9146 begin("jtt.optimize.DeadCode01");
9147 String runString = null;
9148 try {
9149 // (0) == 4
9150 runString = "(0)";
9151 if (4 != jtt.optimize.DeadCode01.test(0)) {
9152 fail(runString);
9153 return;
9154 }
9155 // (1) == 5
9156 runString = "(1)";
9157 if (5 != jtt.optimize.DeadCode01.test(1)) {
9158 fail(runString);
9159 return;
9160 }
9161 // (2) == 6
9162 runString = "(2)";
9163 if (6 != jtt.optimize.DeadCode01.test(2)) {
9164 fail(runString);
9165 return;
9166 }
9167 // (3) == 4
9168 runString = "(3)";
9169 if (4 != jtt.optimize.DeadCode01.test(3)) {
9170 fail(runString);
9171 return;
9172 }
9173 // (4) == 5
9174 runString = "(4)";
9175 if (5 != jtt.optimize.DeadCode01.test(4)) {
9176 fail(runString);
9177 return;
9178 }
9179 // (6) == 7
9180 runString = "(6)";
9181 if (7 != jtt.optimize.DeadCode01.test(6)) {
9182 fail(runString);
9183 return;
9184 }
9185 } catch (Throwable t) {
9186 fail(runString, t);
9187 return;
9188 }
9189 pass();
9190 }
9191
9192 static void jtt_optimize_Fold_Cast01() {
9193 begin("jtt.optimize.Fold_Cast01");
9194 String runString = null;
9195 try {
9196 // (0) == 9
9197 runString = "(0)";
9198 if (9 != jtt.optimize.Fold_Cast01.test(0)) {
9199 fail(runString);
9200 return;
9201 }
9202 // (1) == 9
9203 runString = "(1)";
9204 if (9 != jtt.optimize.Fold_Cast01.test(1)) {
9205 fail(runString);
9206 return;
9207 }
9208 // (2) == !java.lang.NullPointerException
9209 try {
9210 runString = "(2)";
9211 jtt.optimize.Fold_Cast01.test(2);
9212 fail(runString);
9213 return;
9214 } catch (Throwable e) {
9215 if (e.getClass() != java.lang.NullPointerException.class) {
9216 fail(runString, e);
9217 return;
9218 }
9219 }
9220 } catch (Throwable t) {
9221 fail(runString, t);
9222 return;
9223 }
9224 pass();
9225 }
9226
9227 static void jtt_optimize_Fold_Convert01() {
9228 begin("jtt.optimize.Fold_Convert01");
9229 String runString = null;
9230 try {
9231 // (0) == -128
9232 runString = "(0)";
9233 if (-128 != jtt.optimize.Fold_Convert01.test(0)) {
9234 fail(runString);
9235 return;
9236 }
9237 // (1) == -32768
9238 runString = "(1)";
9239 if (-32768 != jtt.optimize.Fold_Convert01.test(1)) {
9240 fail(runString);
9241 return;
9242 }
9243 // (2) == 65535
9244 runString = "(2)";
9245 if (65535 != jtt.optimize.Fold_Convert01.test(2)) {
9246 fail(runString);
9247 return;
9248 }
9249 } catch (Throwable t) {
9250 fail(runString, t);
9251 return;
9252 }
9253 pass();
9254 }
9255
9256 static void jtt_optimize_Fold_Convert02() {
9257 begin("jtt.optimize.Fold_Convert02");
9258 String runString = null;
9259 try {
9260 // (0) == -2147483648
9261 runString = "(0)";
9262 if (-2147483648L != jtt.optimize.Fold_Convert02.test(0)) {
9263 fail(runString);
9264 return;
9265 }
9266 // (1) == -33
9267 runString = "(1)";
9268 if (-33L != jtt.optimize.Fold_Convert02.test(1)) {
9269 fail(runString);
9270 return;
9271 }
9272 // (2) == -78
9273 runString = "(2)";
9274 if (-78L != jtt.optimize.Fold_Convert02.test(2)) {
9275 fail(runString);
9276 return;
9277 }
9278 } catch (Throwable t) {
9279 fail(runString, t);
9280 return;
9281 }
9282 pass();
9283 }
9284
9285 static void jtt_optimize_Fold_Convert03() {
9286 begin("jtt.optimize.Fold_Convert03");
9287 String runString = null;
9288 try {
9289 // (0) == 1024.0
9290 runString = "(0)";
9291 if (1024.0f != jtt.optimize.Fold_Convert03.test(0)) {
9292 fail(runString);
9293 return;
9294 }
9295 // (1) == -33.0
9296 runString = "(1)";
9297 if (-33.0f != jtt.optimize.Fold_Convert03.test(1)) {
9298 fail(runString);
9299 return;
9300 }
9301 // (2) == -78.1
9302 runString = "(2)";
9303 if (-78.1f != jtt.optimize.Fold_Convert03.test(2)) {
9304 fail(runString);
9305 return;
9306 }
9307 } catch (Throwable t) {
9308 fail(runString, t);
9309 return;
9310 }
9311 pass();
9312 }
9313
9314 static void jtt_optimize_Fold_Convert04() {
9315 begin("jtt.optimize.Fold_Convert04");
9316 String runString = null;
9317 try {
9318 // (0) == 1024.0
9319 runString = "(0)";
9320 if (1024.0 != jtt.optimize.Fold_Convert04.test(0)) {
9321 fail(runString);
9322 return;
9323 }
9324 // (1) == -1.25
9325 runString = "(1)";
9326 if (-1.25 != jtt.optimize.Fold_Convert04.test(1)) {
9327 fail(runString);
9328 return;
9329 }
9330 } catch (Throwable t) {
9331 fail(runString, t);
9332 return;
9333 }
9334 pass();
9335 }
9336
9337 static void jtt_optimize_Fold_Double01() {
9338 begin("jtt.optimize.Fold_Double01");
9339 String runString = null;
9340 try {
9341 // (0.0) == 10.0
9342 runString = "(0.0)";
9343 if (10.0 != jtt.optimize.Fold_Double01.test(0.0)) {
9344 fail(runString);
9345 return;
9346 }
9347 // (1.0) == 11.0
9348 runString = "(1.0)";
9349 if (11.0 != jtt.optimize.Fold_Double01.test(1.0)) {
9350 fail(runString);
9351 return;
9352 }
9353 // (2.0) == 12.0
9354 runString = "(2.0)";
9355 if (12.0 != jtt.optimize.Fold_Double01.test(2.0)) {
9356 fail(runString);
9357 return;
9358 }
9359 // (3.0) == 13.0
9360 runString = "(3.0)";
9361 if (13.0 != jtt.optimize.Fold_Double01.test(3.0)) {
9362 fail(runString);
9363 return;
9364 }
9365 // (4.0) == 14.0
9366 runString = "(4.0)";
9367 if (14.0 != jtt.optimize.Fold_Double01.test(4.0)) {
9368 fail(runString);
9369 return;
9370 }
9371 } catch (Throwable t) {
9372 fail(runString, t);
9373 return;
9374 }
9375 pass();
9376 }
9377
9378 static void jtt_optimize_Fold_Double02() {
9379 begin("jtt.optimize.Fold_Double02");
9380 String runString = null;
9381 try {
9382 // (0) == true
9383 runString = "(0)";
9384 if (true != jtt.optimize.Fold_Double02.test(0)) {
9385 fail(runString);
9386 return;
9387 }
9388 // (1) == true
9389 runString = "(1)";
9390 if (true != jtt.optimize.Fold_Double02.test(1)) {
9391 fail(runString);
9392 return;
9393 }
9394 // (2) == true
9395 runString = "(2)";
9396 if (true != jtt.optimize.Fold_Double02.test(2)) {
9397 fail(runString);
9398 return;
9399 }
9400 // (3) == false
9401 runString = "(3)";
9402 if (false != jtt.optimize.Fold_Double02.test(3)) {
9403 fail(runString);
9404 return;
9405 }
9406 // (4) == false
9407 runString = "(4)";
9408 if (false != jtt.optimize.Fold_Double02.test(4)) {
9409 fail(runString);
9410 return;
9411 }
9412 // (5) == false
9413 runString = "(5)";
9414 if (false != jtt.optimize.Fold_Double02.test(5)) {
9415 fail(runString);
9416 return;
9417 }
9418 } catch (Throwable t) {
9419 fail(runString, t);
9420 return;
9421 }
9422 pass();
9423 }
9424
9425 static void jtt_optimize_Fold_Float01() {
9426 begin("jtt.optimize.Fold_Float01");
9427 String runString = null;
9428 try {
9429 // (0.0) == 10.0
9430 runString = "(0.0)";
9431 if (10.0f != jtt.optimize.Fold_Float01.test(0.0f)) {
9432 fail(runString);
9433 return;
9434 }
9435 // (1.0) == 11.0
9436 runString = "(1.0)";
9437 if (11.0f != jtt.optimize.Fold_Float01.test(1.0f)) {
9438 fail(runString);
9439 return;
9440 }
9441 // (2.0) == 12.0
9442 runString = "(2.0)";
9443 if (12.0f != jtt.optimize.Fold_Float01.test(2.0f)) {
9444 fail(runString);
9445 return;
9446 }
9447 // (3.0) == 13.0
9448 runString = "(3.0)";
9449 if (13.0f != jtt.optimize.Fold_Float01.test(3.0f)) {
9450 fail(runString);
9451 return;
9452 }
9453 // (4.0) == 14.0
9454 runString = "(4.0)";
9455 if (14.0f != jtt.optimize.Fold_Float01.test(4.0f)) {
9456 fail(runString);
9457 return;
9458 }
9459 } catch (Throwable t) {
9460 fail(runString, t);
9461 return;
9462 }
9463 pass();
9464 }
9465
9466 static void jtt_optimize_Fold_Float02() {
9467 begin("jtt.optimize.Fold_Float02");
9468 String runString = null;
9469 try {
9470 // (0) == true
9471 runString = "(0)";
9472 if (true != jtt.optimize.Fold_Float02.test(0)) {
9473 fail(runString);
9474 return;
9475 }
9476 // (1) == true
9477 runString = "(1)";
9478 if (true != jtt.optimize.Fold_Float02.test(1)) {
9479 fail(runString);
9480 return;
9481 }
9482 // (2) == true
9483 runString = "(2)";
9484 if (true != jtt.optimize.Fold_Float02.test(2)) {
9485 fail(runString);
9486 return;
9487 }
9488 // (3) == false
9489 runString = "(3)";
9490 if (false != jtt.optimize.Fold_Float02.test(3)) {
9491 fail(runString);
9492 return;
9493 }
9494 // (4) == false
9495 runString = "(4)";
9496 if (false != jtt.optimize.Fold_Float02.test(4)) {
9497 fail(runString);
9498 return;
9499 }
9500 // (5) == false
9501 runString = "(5)";
9502 if (false != jtt.optimize.Fold_Float02.test(5)) {
9503 fail(runString);
9504 return;
9505 }
9506 } catch (Throwable t) {
9507 fail(runString, t);
9508 return;
9509 }
9510 pass();
9511 }
9512
9513 static void jtt_optimize_Fold_InstanceOf01() {
9514 begin("jtt.optimize.Fold_InstanceOf01");
9515 String runString = null;
9516 try {
9517 // (0) == true
9518 runString = "(0)";
9519 if (true != jtt.optimize.Fold_InstanceOf01.test(0)) {
9520 fail(runString);
9521 return;
9522 }
9523 // (1) == true
9524 runString = "(1)";
9525 if (true != jtt.optimize.Fold_InstanceOf01.test(1)) {
9526 fail(runString);
9527 return;
9528 }
9529 // (2) == false
9530 runString = "(2)";
9531 if (false != jtt.optimize.Fold_InstanceOf01.test(2)) {
9532 fail(runString);
9533 return;
9534 }
9535 } catch (Throwable t) {
9536 fail(runString, t);
9537 return;
9538 }
9539 pass();
9540 }
9541
9542 static void jtt_optimize_Fold_Int01() {
9543 begin("jtt.optimize.Fold_Int01");
9544 String runString = null;
9545 try {
9546 // (0) == 10
9547 runString = "(0)";
9548 if (10 != jtt.optimize.Fold_Int01.test(0)) {
9549 fail(runString);
9550 return;
9551 }
9552 // (1) == 11
9553 runString = "(1)";
9554 if (11 != jtt.optimize.Fold_Int01.test(1)) {
9555 fail(runString);
9556 return;
9557 }
9558 // (2) == 12
9559 runString = "(2)";
9560 if (12 != jtt.optimize.Fold_Int01.test(2)) {
9561 fail(runString);
9562 return;
9563 }
9564 // (3) == 13
9565 runString = "(3)";
9566 if (13 != jtt.optimize.Fold_Int01.test(3)) {
9567 fail(runString);
9568 return;
9569 }
9570 // (4) == 14
9571 runString = "(4)";
9572 if (14 != jtt.optimize.Fold_Int01.test(4)) {
9573 fail(runString);
9574 return;
9575 }
9576 // (5) == 15
9577 runString = "(5)";
9578 if (15 != jtt.optimize.Fold_Int01.test(5)) {
9579 fail(runString);
9580 return;
9581 }
9582 // (6) == 16
9583 runString = "(6)";
9584 if (16 != jtt.optimize.Fold_Int01.test(6)) {
9585 fail(runString);
9586 return;
9587 }
9588 // (7) == 17
9589 runString = "(7)";
9590 if (17 != jtt.optimize.Fold_Int01.test(7)) {
9591 fail(runString);
9592 return;
9593 }
9594 } catch (Throwable t) {
9595 fail(runString, t);
9596 return;
9597 }
9598 pass();
9599 }
9600
9601 static void jtt_optimize_Fold_Int02() {
9602 begin("jtt.optimize.Fold_Int02");
9603 String runString = null;
9604 try {
9605 // (0) == true
9606 runString = "(0)";
9607 if (true != jtt.optimize.Fold_Int02.test(0)) {
9608 fail(runString);
9609 return;
9610 }
9611 // (1) == true
9612 runString = "(1)";
9613 if (true != jtt.optimize.Fold_Int02.test(1)) {
9614 fail(runString);
9615 return;
9616 }
9617 // (2) == true
9618 runString = "(2)";
9619 if (true != jtt.optimize.Fold_Int02.test(2)) {
9620 fail(runString);
9621 return;
9622 }
9623 // (3) == false
9624 runString = "(3)";
9625 if (false != jtt.optimize.Fold_Int02.test(3)) {
9626 fail(runString);
9627 return;
9628 }
9629 // (4) == false
9630 runString = "(4)";
9631 if (false != jtt.optimize.Fold_Int02.test(4)) {
9632 fail(runString);
9633 return;
9634 }
9635 // (5) == false
9636 runString = "(5)";
9637 if (false != jtt.optimize.Fold_Int02.test(5)) {
9638 fail(runString);
9639 return;
9640 }
9641 } catch (Throwable t) {
9642 fail(runString, t);
9643 return;
9644 }
9645 pass();
9646 }
9647
9648 static void jtt_optimize_Fold_Long01() {
9649 begin("jtt.optimize.Fold_Long01");
9650 String runString = null;
9651 try {
9652 // (0) == 10
9653 runString = "(0)";
9654 if (10L != jtt.optimize.Fold_Long01.test(0)) {
9655 fail(runString);
9656 return;
9657 }
9658 // (1) == 11
9659 runString = "(1)";
9660 if (11L != jtt.optimize.Fold_Long01.test(1)) {
9661 fail(runString);
9662 return;
9663 }
9664 // (2) == 12
9665 runString = "(2)";
9666 if (12L != jtt.optimize.Fold_Long01.test(2)) {
9667 fail(runString);
9668 return;
9669 }
9670 // (3) == 13
9671 runString = "(3)";
9672 if (13L != jtt.optimize.Fold_Long01.test(3)) {
9673 fail(runString);
9674 return;
9675 }
9676 // (4) == 14
9677 runString = "(4)";
9678 if (14L != jtt.optimize.Fold_Long01.test(4)) {
9679 fail(runString);
9680 return;
9681 }
9682 // (5) == 15
9683 runString = "(5)";
9684 if (15L != jtt.optimize.Fold_Long01.test(5)) {
9685 fail(runString);
9686 return;
9687 }
9688 // (6) == 16
9689 runString = "(6)";
9690 if (16L != jtt.optimize.Fold_Long01.test(6)) {
9691 fail(runString);
9692 return;
9693 }
9694 // (7) == 17
9695 runString = "(7)";
9696 if (17L != jtt.optimize.Fold_Long01.test(7)) {
9697 fail(runString);
9698 return;
9699 }
9700 } catch (Throwable t) {
9701 fail(runString, t);
9702 return;
9703 }
9704 pass();
9705 }
9706
9707 static void jtt_optimize_Fold_Long02() {
9708 begin("jtt.optimize.Fold_Long02");
9709 String runString = null;
9710 try {
9711 // (0) == true
9712 runString = "(0)";
9713 if (true != jtt.optimize.Fold_Long02.test(0)) {
9714 fail(runString);
9715 return;
9716 }
9717 // (1) == true
9718 runString = "(1)";
9719 if (true != jtt.optimize.Fold_Long02.test(1)) {
9720 fail(runString);
9721 return;
9722 }
9723 // (2) == true
9724 runString = "(2)";
9725 if (true != jtt.optimize.Fold_Long02.test(2)) {
9726 fail(runString);
9727 return;
9728 }
9729 // (3) == false
9730 runString = "(3)";
9731 if (false != jtt.optimize.Fold_Long02.test(3)) {
9732 fail(runString);
9733 return;
9734 }
9735 // (4) == false
9736 runString = "(4)";
9737 if (false != jtt.optimize.Fold_Long02.test(4)) {
9738 fail(runString);
9739 return;
9740 }
9741 // (5) == false
9742 runString = "(5)";
9743 if (false != jtt.optimize.Fold_Long02.test(5)) {
9744 fail(runString);
9745 return;
9746 }
9747 } catch (Throwable t) {
9748 fail(runString, t);
9749 return;
9750 }
9751 pass();
9752 }
9753
9754 static void jtt_optimize_Fold_Math01() {
9755 begin("jtt.optimize.Fold_Math01");
9756 String runString = null;
9757 try {
9758 // (0) == 10.0
9759 runString = "(0)";
9760 if (10.0 != jtt.optimize.Fold_Math01.test(0)) {
9761 fail(runString);
9762 return;
9763 }
9764 // (1) == 0.14943813247359922
9765 runString = "(1)";
9766 if (0.14943813247359922 != jtt.optimize.Fold_Math01.test(1)) {
9767 fail(runString);
9768 return;
9769 }
9770 // (2) == 0.9887710779360422
9771 runString = "(2)";
9772 if (0.9887710779360422 != jtt.optimize.Fold_Math01.test(2)) {
9773 fail(runString);
9774 return;
9775 }
9776 // (3) == 0.15113521805829508
9777 runString = "(3)";
9778 if (0.15113521805829508 != jtt.optimize.Fold_Math01.test(3)) {
9779 fail(runString);
9780 return;
9781 }
9782 // (4) == 0.04834938665190287
9783 runString = "(4)";
9784 if (0.04834938665190287 != jtt.optimize.Fold_Math01.test(4)) {
9785 fail(runString);
9786 return;
9787 }
9788 // (5) == 12.0
9789 runString = "(5)";
9790 if (12.0 != jtt.optimize.Fold_Math01.test(5)) {
9791 fail(runString);
9792 return;
9793 }
9794 // (6) == 1.1474024528375417
9795 runString = "(6)";
9796 if (1.1474024528375417 != jtt.optimize.Fold_Math01.test(6)) {
9797 fail(runString);
9798 return;
9799 }
9800 // (7) == -0.8239087409443188
9801 runString = "(7)";
9802 if (-0.8239087409443188 != jtt.optimize.Fold_Math01.test(7)) {
9803 fail(runString);
9804 return;
9805 }
9806 // (8) == 106.62882057436371
9807 runString = "(8)";
9808 if (106.62882057436371 != jtt.optimize.Fold_Math01.test(8)) {
9809 fail(runString);
9810 return;
9811 }
9812 // (9) == 1.1474024528375417
9813 runString = "(9)";
9814 if (1.1474024528375417 != jtt.optimize.Fold_Math01.test(9)) {
9815 fail(runString);
9816 return;
9817 }
9818 // (10) == -1.0
9819 runString = "(10)";
9820 if (-1.0 != jtt.optimize.Fold_Math01.test(10)) {
9821 fail(runString);
9822 return;
9823 }
9824 // (11) == 2.0
9825 runString = "(11)";
9826 if (2.0 != jtt.optimize.Fold_Math01.test(11)) {
9827 fail(runString);
9828 return;
9829 }
9830 // (12) == 42.0
9831 runString = "(12)";
9832 if (42.0 != jtt.optimize.Fold_Math01.test(12)) {
9833 fail(runString);
9834 return;
9835 }
9836 } catch (Throwable t) {
9837 fail(runString, t);
9838 return;
9839 }
9840 pass();
9841 }
9842
9843 static void jtt_optimize_Inline01() {
9844 begin("jtt.optimize.Inline01");
9845 String runString = null;
9846 try {
9847 // (0) == 2
9848 runString = "(0)";
9849 if (2 != jtt.optimize.Inline01.test(0)) {
9850 fail(runString);
9851 return;
9852 }
9853 // (1) == 3
9854 runString = "(1)";
9855 if (3 != jtt.optimize.Inline01.test(1)) {
9856 fail(runString);
9857 return;
9858 }
9859 } catch (Throwable t) {
9860 fail(runString, t);
9861 return;
9862 }
9863 pass();
9864 }
9865
9866 static void jtt_optimize_Inline02() {
9867 begin("jtt.optimize.Inline02");
9868 String runString = null;
9869 try {
9870 // (0) == 2
9871 runString = "(0)";
9872 if (2 != jtt.optimize.Inline02.test(0)) {
9873 fail(runString);
9874 return;
9875 }
9876 // (1) == 5
9877 runString = "(1)";
9878 if (5 != jtt.optimize.Inline02.test(1)) {
9879 fail(runString);
9880 return;
9881 }
9882 // (2) == 8
9883 runString = "(2)";
9884 if (8 != jtt.optimize.Inline02.test(2)) {
9885 fail(runString);
9886 return;
9887 }
9888 } catch (Throwable t) {
9889 fail(runString, t);
9890 return;
9891 }
9892 pass();
9893 }
9894
9895 static void jtt_optimize_List_reorder_bug() {
9896 begin("jtt.optimize.List_reorder_bug");
9897 String runString = null;
9898 try {
9899 // (0) == true
9900 runString = "(0)";
9901 if (true != jtt.optimize.List_reorder_bug.test(0)) {
9902 fail(runString);
9903 return;
9904 }
9905 } catch (Throwable t) {
9906 fail(runString, t);
9907 return;
9908 }
9909 pass();
9910 }
9911
9912 static void jtt_optimize_NCE_01() {
9913 begin("jtt.optimize.NCE_01");
9914 String runString = null;
9915 try {
9916 // (0) == 45
9917 runString = "(0)";
9918 if (45 != jtt.optimize.NCE_01.test(0)) {
9919 fail(runString);
9920 return;
9921 }
9922 } catch (Throwable t) {
9923 fail(runString, t);
9924 return;
9925 }
9926 pass();
9927 }
9928
9929 static void jtt_optimize_NCE_02() {
9930 begin("jtt.optimize.NCE_02");
9931 String runString = null;
9932 try {
9933 // (0) == 23
9934 runString = "(0)";
9935 if (23 != jtt.optimize.NCE_02.test(0)) {
9936 fail(runString);
9937 return;
9938 }
9939 } catch (Throwable t) {
9940 fail(runString, t);
9941 return;
9942 }
9943 pass();
9944 }
9945
9946 static void jtt_optimize_NCE_03() {
9947 begin("jtt.optimize.NCE_03");
9948 String runString = null;
9949 try {
9950 // (0) == 23
9951 runString = "(0)";
9952 if (23 != jtt.optimize.NCE_03.test(0)) {
9953 fail(runString);
9954 return;
9955 }
9956 } catch (Throwable t) {
9957 fail(runString, t);
9958 return;
9959 }
9960 pass();
9961 }
9962
9963 static void jtt_optimize_NCE_04() {
9964 begin("jtt.optimize.NCE_04");
9965 String runString = null;
9966 try {
9967 // (0) == 23
9968 runString = "(0)";
9969 if (23 != jtt.optimize.NCE_04.test(0)) {
9970 fail(runString);
9971 return;
9972 }
9973 } catch (Throwable t) {
9974 fail(runString, t);
9975 return;
9976 }
9977 pass();
9978 }
9979
9980 static void jtt_optimize_NCE_FlowSensitive01() {
9981 begin("jtt.optimize.NCE_FlowSensitive01");
9982 String runString = null;
9983 try {
9984 // (null) == null
9985 runString = "(null)";
9986 if (null != jtt.optimize.NCE_FlowSensitive01.test(null)) {
9987 fail(runString);
9988 return;
9989 }
9990 // ("x") == "x"
9991 runString = "(\"x\")";
9992 if (!"x".equals(jtt.optimize.NCE_FlowSensitive01.test("x"))) {
9993 fail(runString);
9994 return;
9995 }
9996 // ("yay") == "yay"
9997 runString = "(\"yay\")";
9998 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive01.test("yay"))) {
9999 fail(runString);
10000 return;
10001 }
10002 } catch (Throwable t) {
10003 fail(runString, t);
10004 return;
10005 }
10006 pass();
10007 }
10008
10009 static void jtt_optimize_NCE_FlowSensitive02() {
10010 begin("jtt.optimize.NCE_FlowSensitive02");
10011 String runString = null;
10012 try {
10013 // (null) == !java.lang.NullPointerException
10014 try {
10015 runString = "(null)";
10016 jtt.optimize.NCE_FlowSensitive02.test(null);
10017 fail(runString);
10018 return;
10019 } catch (Throwable e) {
10020 if (e.getClass() != java.lang.NullPointerException.class) {
10021 fail(runString, e);
10022 return;
10023 }
10024 }
10025 // ("x") == "x"
10026 runString = "(\"x\")";
10027 if (!"x".equals(jtt.optimize.NCE_FlowSensitive02.test("x"))) {
10028 fail(runString);
10029 return;
10030 }
10031 // ("yay") == "yay"
10032 runString = "(\"yay\")";
10033 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive02.test("yay"))) {
10034 fail(runString);
10035 return;
10036 }
10037 } catch (Throwable t) {
10038 fail(runString, t);
10039 return;
10040 }
10041 pass();
10042 }
10043
10044 static void jtt_optimize_NCE_FlowSensitive03() {
10045 begin("jtt.optimize.NCE_FlowSensitive03");
10046 String runString = null;
10047 try {
10048 // (null) == "null"
10049 runString = "(null)";
10050 if (!"null".equals(jtt.optimize.NCE_FlowSensitive03.test(null))) {
10051 fail(runString);
10052 return;
10053 }
10054 // ("x") == "x"
10055 runString = "(\"x\")";
10056 if (!"x".equals(jtt.optimize.NCE_FlowSensitive03.test("x"))) {
10057 fail(runString);
10058 return;
10059 }
10060 // ("yay") == "yay"
10061 runString = "(\"yay\")";
10062 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive03.test("yay"))) {
10063 fail(runString);
10064 return;
10065 }
10066 } catch (Throwable t) {
10067 fail(runString, t);
10068 return;
10069 }
10070 pass();
10071 }
10072
10073 static void jtt_optimize_NCE_FlowSensitive04() {
10074 begin("jtt.optimize.NCE_FlowSensitive04");
10075 String runString = null;
10076 try {
10077 // (null) == "null"
10078 runString = "(null)";
10079 if (!"null".equals(jtt.optimize.NCE_FlowSensitive04.test(null))) {
10080 fail(runString);
10081 return;
10082 }
10083 // ("x") == "x"
10084 runString = "(\"x\")";
10085 if (!"x".equals(jtt.optimize.NCE_FlowSensitive04.test("x"))) {
10086 fail(runString);
10087 return;
10088 }
10089 // ("yay") == "yay"
10090 runString = "(\"yay\")";
10091 if (!"yay".equals(jtt.optimize.NCE_FlowSensitive04.test("yay"))) {
10092 fail(runString);
10093 return;
10094 }
10095 } catch (Throwable t) {
10096 fail(runString, t);
10097 return;
10098 }
10099 pass();
10100 }
10101
10102 static void jtt_optimize_Narrow_byte01() {
10103 begin("jtt.optimize.Narrow_byte01");
10104 String runString = null;
10105 try {
10106 // (0) == 0
10107 runString = "(0)";
10108 if ((byte) 0 != jtt.optimize.Narrow_byte01.test((byte) 0)) {
10109 fail(runString);
10110 return;
10111 }
10112 // (1) == 1
10113 runString = "(1)";
10114 if ((byte) 1 != jtt.optimize.Narrow_byte01.test((byte) 1)) {
10115 fail(runString);
10116 return;
10117 }
10118 // (-1) == -1
10119 runString = "(-1)";
10120 if ((byte) -1 != jtt.optimize.Narrow_byte01.test((byte) -1)) {
10121 fail(runString);
10122 return;
10123 }
10124 // (110) == 110
10125 runString = "(110)";
10126 if ((byte) 110 != jtt.optimize.Narrow_byte01.test((byte) 110)) {
10127 fail(runString);
10128 return;
10129 }
10130 } catch (Throwable t) {
10131 fail(runString, t);
10132 return;
10133 }
10134 pass();
10135 }
10136
10137 static void jtt_optimize_Narrow_byte02() {
10138 begin("jtt.optimize.Narrow_byte02");
10139 String runString = null;
10140 try {
10141 // (0) == 0
10142 runString = "(0)";
10143 if ((byte) 0 != jtt.optimize.Narrow_byte02.test((byte) 0)) {
10144 fail(runString);
10145 return;
10146 }
10147 // (1) == 1
10148 runString = "(1)";
10149 if ((byte) 1 != jtt.optimize.Narrow_byte02.test((byte) 1)) {
10150 fail(runString);
10151 return;
10152 }
10153 // (-1) == -1
10154 runString = "(-1)";
10155 if ((byte) -1 != jtt.optimize.Narrow_byte02.test((byte) -1)) {
10156 fail(runString);
10157 return;
10158 }
10159 // (110) == 110
10160 runString = "(110)";
10161 if ((byte) 110 != jtt.optimize.Narrow_byte02.test((byte) 110)) {
10162 fail(runString);
10163 return;
10164 }
10165 } catch (Throwable t) {
10166 fail(runString, t);
10167 return;
10168 }
10169 pass();
10170 }
10171
10172 static void jtt_optimize_Narrow_byte03() {
10173 begin("jtt.optimize.Narrow_byte03");
10174 String runString = null;
10175 try {
10176 // (0) == 0
10177 runString = "(0)";
10178 if ((byte) 0 != jtt.optimize.Narrow_byte03.test((byte) 0)) {
10179 fail(runString);
10180 return;
10181 }
10182 // (1) == 1
10183 runString = "(1)";
10184 if ((byte) 1 != jtt.optimize.Narrow_byte03.test((byte) 1)) {
10185 fail(runString);
10186 return;
10187 }
10188 // (-1) == -1
10189 runString = "(-1)";
10190 if ((byte) -1 != jtt.optimize.Narrow_byte03.test((byte) -1)) {
10191 fail(runString);
10192 return;
10193 }
10194 // (110) == 110
10195 runString = "(110)";
10196 if ((byte) 110 != jtt.optimize.Narrow_byte03.test((byte) 110)) {
10197 fail(runString);
10198 return;
10199 }
10200 } catch (Throwable t) {
10201 fail(runString, t);
10202 return;
10203 }
10204 pass();
10205 }
10206
10207 static void jtt_optimize_Narrow_char01() {
10208 begin("jtt.optimize.Narrow_char01");
10209 String runString = null;
10210 try {
10211 // ('\0') == '\0'
10212 runString = "('\0')";
10213 if ((char) 0 != jtt.optimize.Narrow_char01.test((char) 0)) {
10214 fail(runString);
10215 return;
10216 }
10217 // ('\1') == '\1'
10218 runString = "('\1')";
10219 if ((char) 1 != jtt.optimize.Narrow_char01.test((char) 1)) {
10220 fail(runString);
10221 return;
10222 }
10223 // ('\377') == '\377'
10224 runString = "('\377')";
10225 if ((char) 255 != jtt.optimize.Narrow_char01.test((char) 255)) {
10226 fail(runString);
10227 return;
10228 }
10229 // ('\176750') == '\176750'
10230 runString = "('\176750')";
10231 if ((char) 65000 != jtt.optimize.Narrow_char01.test((char) 65000)) {
10232 fail(runString);
10233 return;
10234 }
10235 } catch (Throwable t) {
10236 fail(runString, t);
10237 return;
10238 }
10239 pass();
10240 }
10241
10242 static void jtt_optimize_Narrow_char02() {
10243 begin("jtt.optimize.Narrow_char02");
10244 String runString = null;
10245 try {
10246 // ('\0') == '\0'
10247 runString = "('\0')";
10248 if ((char) 0 != jtt.optimize.Narrow_char02.test((char) 0)) {
10249 fail(runString);
10250 return;
10251 }
10252 // ('\1') == '\1'
10253 runString = "('\1')";
10254 if ((char) 1 != jtt.optimize.Narrow_char02.test((char) 1)) {
10255 fail(runString);
10256 return;
10257 }
10258 // ('\377') == '\377'
10259 runString = "('\377')";
10260 if ((char) 255 != jtt.optimize.Narrow_char02.test((char) 255)) {
10261 fail(runString);
10262 return;
10263 }
10264 // ('\176750') == '\176750'
10265 runString = "('\176750')";
10266 if ((char) 65000 != jtt.optimize.Narrow_char02.test((char) 65000)) {
10267 fail(runString);
10268 return;
10269 }
10270 } catch (Throwable t) {
10271 fail(runString, t);
10272 return;
10273 }
10274 pass();
10275 }
10276
10277 static void jtt_optimize_Narrow_char03() {
10278 begin("jtt.optimize.Narrow_char03");
10279 String runString = null;
10280 try {
10281 // ('\0') == '\0'
10282 runString = "('\0')";
10283 if ((char) 0 != jtt.optimize.Narrow_char03.test((char) 0)) {
10284 fail(runString);
10285 return;
10286 }
10287 // ('\1') == '\1'
10288 runString = "('\1')";
10289 if ((char) 1 != jtt.optimize.Narrow_char03.test((char) 1)) {
10290 fail(runString);
10291 return;
10292 }
10293 // ('\377') == '\377'
10294 runString = "('\377')";
10295 if ((char) 255 != jtt.optimize.Narrow_char03.test((char) 255)) {
10296 fail(runString);
10297 return;
10298 }
10299 // ('\176750') == '\176750'
10300 runString = "('\176750')";
10301 if ((char) 65000 != jtt.optimize.Narrow_char03.test((char) 65000)) {
10302 fail(runString);
10303 return;
10304 }
10305 } catch (Throwable t) {
10306 fail(runString, t);
10307 return;
10308 }
10309 pass();
10310 }
10311
10312 static void jtt_optimize_Narrow_short01() {
10313 begin("jtt.optimize.Narrow_short01");
10314 String runString = null;
10315 try {
10316 // (0) == 0
10317 runString = "(0)";
10318 if ((short) 0 != jtt.optimize.Narrow_short01.test((short) 0)) {
10319 fail(runString);
10320 return;
10321 }
10322 // (1) == 1
10323 runString = "(1)";
10324 if ((short) 1 != jtt.optimize.Narrow_short01.test((short) 1)) {
10325 fail(runString);
10326 return;
10327 }
10328 // (-1) == -1
10329 runString = "(-1)";
10330 if ((short) -1 != jtt.optimize.Narrow_short01.test((short) -1)) {
10331 fail(runString);
10332 return;
10333 }
10334 // (23110) == 23110
10335 runString = "(23110)";
10336 if ((short) 23110 != jtt.optimize.Narrow_short01
10337 .test((short) 23110)) {
10338 fail(runString);
10339 return;
10340 }
10341 } catch (Throwable t) {
10342 fail(runString, t);
10343 return;
10344 }
10345 pass();
10346 }
10347
10348 static void jtt_optimize_Narrow_short02() {
10349 begin("jtt.optimize.Narrow_short02");
10350 String runString = null;
10351 try {
10352 // (0) == 0
10353 runString = "(0)";
10354 if ((short) 0 != jtt.optimize.Narrow_short02.test((short) 0)) {
10355 fail(runString);
10356 return;
10357 }
10358 // (1) == 1
10359 runString = "(1)";
10360 if ((short) 1 != jtt.optimize.Narrow_short02.test((short) 1)) {
10361 fail(runString);
10362 return;
10363 }
10364 // (-1) == -1
10365 runString = "(-1)";
10366 if ((short) -1 != jtt.optimize.Narrow_short02.test((short) -1)) {
10367 fail(runString);
10368 return;
10369 }
10370 // (23110) == 23110
10371 runString = "(23110)";
10372 if ((short) 23110 != jtt.optimize.Narrow_short02
10373 .test((short) 23110)) {
10374 fail(runString);
10375 return;
10376 }
10377 } catch (Throwable t) {
10378 fail(runString, t);
10379 return;
10380 }
10381 pass();
10382 }
10383
10384 static void jtt_optimize_Narrow_short03() {
10385 begin("jtt.optimize.Narrow_short03");
10386 String runString = null;
10387 try {
10388 // (0) == 0
10389 runString = "(0)";
10390 if ((short) 0 != jtt.optimize.Narrow_short03.test((short) 0)) {
10391 fail(runString);
10392 return;
10393 }
10394 // (1) == 1
10395 runString = "(1)";
10396 if ((short) 1 != jtt.optimize.Narrow_short03.test((short) 1)) {
10397 fail(runString);
10398 return;
10399 }
10400 // (-1) == -1
10401 runString = "(-1)";
10402 if ((short) -1 != jtt.optimize.Narrow_short03.test((short) -1)) {
10403 fail(runString);
10404 return;
10405 }
10406 // (23110) == 23110
10407 runString = "(23110)";
10408 if ((short) 23110 != jtt.optimize.Narrow_short03
10409 .test((short) 23110)) {
10410 fail(runString);
10411 return;
10412 }
10413 } catch (Throwable t) {
10414 fail(runString, t);
10415 return;
10416 }
10417 pass();
10418 }
10419
10420 static void jtt_optimize_Phi01() {
10421 begin("jtt.optimize.Phi01");
10422 String runString = null;
10423 try {
10424 // (0) == 8
10425 runString = "(0)";
10426 if (8 != jtt.optimize.Phi01.test(0)) {
10427 fail(runString);
10428 return;
10429 }
10430 // (1) == 10
10431 runString = "(1)";
10432 if (10 != jtt.optimize.Phi01.test(1)) {
10433 fail(runString);
10434 return;
10435 }
10436 // (2) == 12
10437 runString = "(2)";
10438 if (12 != jtt.optimize.Phi01.test(2)) {
10439 fail(runString);
10440 return;
10441 }
10442 // (3) == 8
10443 runString = "(3)";
10444 if (8 != jtt.optimize.Phi01.test(3)) {
10445 fail(runString);
10446 return;
10447 }
10448 // (4) == 10
10449 runString = "(4)";
10450 if (10 != jtt.optimize.Phi01.test(4)) {
10451 fail(runString);
10452 return;
10453 }
10454 // (6) == 14
10455 runString = "(6)";
10456 if (14 != jtt.optimize.Phi01.test(6)) {
10457 fail(runString);
10458 return;
10459 }
10460 } catch (Throwable t) {
10461 fail(runString, t);
10462 return;
10463 }
10464 pass();
10465 }
10466
10467 static void jtt_optimize_Phi02() {
10468 begin("jtt.optimize.Phi02");
10469 String runString = null;
10470 try {
10471 // (0) == 8
10472 runString = "(0)";
10473 if (8 != jtt.optimize.Phi02.test(0)) {
10474 fail(runString);
10475 return;
10476 }
10477 // (1) == 10
10478 runString = "(1)";
10479 if (10 != jtt.optimize.Phi02.test(1)) {
10480 fail(runString);
10481 return;
10482 }
10483 // (2) == 12
10484 runString = "(2)";
10485 if (12 != jtt.optimize.Phi02.test(2)) {
10486 fail(runString);
10487 return;
10488 }
10489 // (3) == 8
10490 runString = "(3)";
10491 if (8 != jtt.optimize.Phi02.test(3)) {
10492 fail(runString);
10493 return;
10494 }
10495 // (4) == 10
10496 runString = "(4)";
10497 if (10 != jtt.optimize.Phi02.test(4)) {
10498 fail(runString);
10499 return;
10500 }
10501 // (6) == 14
10502 runString = "(6)";
10503 if (14 != jtt.optimize.Phi02.test(6)) {
10504 fail(runString);
10505 return;
10506 }
10507 } catch (Throwable t) {
10508 fail(runString, t);
10509 return;
10510 }
10511 pass();
10512 }
10513
10514 static void jtt_optimize_Phi03() {
10515 begin("jtt.optimize.Phi03");
10516 String runString = null;
10517 try {
10518 // (0) == 4
10519 runString = "(0)";
10520 if (4 != jtt.optimize.Phi03.test(0)) {
10521 fail(runString);
10522 return;
10523 }
10524 // (1) == 5
10525 runString = "(1)";
10526 if (5 != jtt.optimize.Phi03.test(1)) {
10527 fail(runString);
10528 return;
10529 }
10530 // (2) == 6
10531 runString = "(2)";
10532 if (6 != jtt.optimize.Phi03.test(2)) {
10533 fail(runString);
10534 return;
10535 }
10536 // (3) == 4
10537 runString = "(3)";
10538 if (4 != jtt.optimize.Phi03.test(3)) {
10539 fail(runString);
10540 return;
10541 }
10542 // (4) == 5
10543 runString = "(4)";
10544 if (5 != jtt.optimize.Phi03.test(4)) {
10545 fail(runString);
10546 return;
10547 }
10548 // (6) == 7
10549 runString = "(6)";
10550 if (7 != jtt.optimize.Phi03.test(6)) {
10551 fail(runString);
10552 return;
10553 }
10554 } catch (Throwable t) {
10555 fail(runString, t);
10556 return;
10557 }
10558 pass();
10559 }
10560
10561 static void jtt_optimize_Reduce_Convert01() {
10562 begin("jtt.optimize.Reduce_Convert01");
10563 String runString = null;
10564 try {
10565 // (0) == 10
10566 runString = "(0)";
10567 if (10 != jtt.optimize.Reduce_Convert01.test(0)) {
10568 fail(runString);
10569 return;
10570 }
10571 // (1) == 11
10572 runString = "(1)";
10573 if (11 != jtt.optimize.Reduce_Convert01.test(1)) {
10574 fail(runString);
10575 return;
10576 }
10577 // (2) == 12
10578 runString = "(2)";
10579 if (12 != jtt.optimize.Reduce_Convert01.test(2)) {
10580 fail(runString);
10581 return;
10582 }
10583 } catch (Throwable t) {
10584 fail(runString, t);
10585 return;
10586 }
10587 pass();
10588 }
10589
10590 static void jtt_optimize_Reduce_Double01() {
10591 begin("jtt.optimize.Reduce_Double01");
10592 String runString = null;
10593 try {
10594 // (0.0) == 10.0
10595 runString = "(0.0)";
10596 if (10.0 != jtt.optimize.Reduce_Double01.test(0.0)) {
10597 fail(runString);
10598 return;
10599 }
10600 // (1.0) == 11.0
10601 runString = "(1.0)";
10602 if (11.0 != jtt.optimize.Reduce_Double01.test(1.0)) {
10603 fail(runString);
10604 return;
10605 }
10606 // (2.0) == 12.0
10607 runString = "(2.0)";
10608 if (12.0 != jtt.optimize.Reduce_Double01.test(2.0)) {
10609 fail(runString);
10610 return;
10611 }
10612 // (3.0) == 13.0
10613 runString = "(3.0)";
10614 if (13.0 != jtt.optimize.Reduce_Double01.test(3.0)) {
10615 fail(runString);
10616 return;
10617 }
10618 } catch (Throwable t) {
10619 fail(runString, t);
10620 return;
10621 }
10622 pass();
10623 }
10624
10625 static void jtt_optimize_Reduce_Float01() {
10626 begin("jtt.optimize.Reduce_Float01");
10627 String runString = null;
10628 try {
10629 // (0.0) == 10.0
10630 runString = "(0.0)";
10631 if (10.0f != jtt.optimize.Reduce_Float01.test(0.0f)) {
10632 fail(runString);
10633 return;
10634 }
10635 // (1.0) == 11.0
10636 runString = "(1.0)";
10637 if (11.0f != jtt.optimize.Reduce_Float01.test(1.0f)) {
10638 fail(runString);
10639 return;
10640 }
10641 // (2.0) == 12.0
10642 runString = "(2.0)";
10643 if (12.0f != jtt.optimize.Reduce_Float01.test(2.0f)) {
10644 fail(runString);
10645 return;
10646 }
10647 // (3.0) == 13.0
10648 runString = "(3.0)";
10649 if (13.0f != jtt.optimize.Reduce_Float01.test(3.0f)) {
10650 fail(runString);
10651 return;
10652 }
10653 } catch (Throwable t) {
10654 fail(runString, t);
10655 return;
10656 }
10657 pass();
10658 }
10659
10660 static void jtt_optimize_Reduce_Int01() {
10661 begin("jtt.optimize.Reduce_Int01");
10662 String runString = null;
10663 try {
10664 // (0) == 10
10665 runString = "(0)";
10666 if (10 != jtt.optimize.Reduce_Int01.test(0)) {
10667 fail(runString);
10668 return;
10669 }
10670 // (1) == 11
10671 runString = "(1)";
10672 if (11 != jtt.optimize.Reduce_Int01.test(1)) {
10673 fail(runString);
10674 return;
10675 }
10676 // (2) == 12
10677 runString = "(2)";
10678 if (12 != jtt.optimize.Reduce_Int01.test(2)) {
10679 fail(runString);
10680 return;
10681 }
10682 // (3) == 13
10683 runString = "(3)";
10684 if (13 != jtt.optimize.Reduce_Int01.test(3)) {
10685 fail(runString);
10686 return;
10687 }
10688 // (4) == 14
10689 runString = "(4)";
10690 if (14 != jtt.optimize.Reduce_Int01.test(4)) {
10691 fail(runString);
10692 return;
10693 }
10694 // (5) == 15
10695 runString = "(5)";
10696 if (15 != jtt.optimize.Reduce_Int01.test(5)) {
10697 fail(runString);
10698 return;
10699 }
10700 // (6) == 16
10701 runString = "(6)";
10702 if (16 != jtt.optimize.Reduce_Int01.test(6)) {
10703 fail(runString);
10704 return;
10705 }
10706 // (7) == 17
10707 runString = "(7)";
10708 if (17 != jtt.optimize.Reduce_Int01.test(7)) {
10709 fail(runString);
10710 return;
10711 }
10712 } catch (Throwable t) {
10713 fail(runString, t);
10714 return;
10715 }
10716 pass();
10717 }
10718
10719 static void jtt_optimize_Reduce_Int02() {
10720 begin("jtt.optimize.Reduce_Int02");
10721 String runString = null;
10722 try {
10723 // (0) == 10
10724 runString = "(0)";
10725 if (10 != jtt.optimize.Reduce_Int02.test(0)) {
10726 fail(runString);
10727 return;
10728 }
10729 // (1) == 11
10730 runString = "(1)";
10731 if (11 != jtt.optimize.Reduce_Int02.test(1)) {
10732 fail(runString);
10733 return;
10734 }
10735 // (2) == 12
10736 runString = "(2)";
10737 if (12 != jtt.optimize.Reduce_Int02.test(2)) {
10738 fail(runString);
10739 return;
10740 }
10741 // (3) == 13
10742 runString = "(3)";
10743 if (13 != jtt.optimize.Reduce_Int02.test(3)) {
10744 fail(runString);
10745 return;
10746 }
10747 // (4) == 14
10748 runString = "(4)";
10749 if (14 != jtt.optimize.Reduce_Int02.test(4)) {
10750 fail(runString);
10751 return;
10752 }
10753 // (5) == 15
10754 runString = "(5)";
10755 if (15 != jtt.optimize.Reduce_Int02.test(5)) {
10756 fail(runString);
10757 return;
10758 }
10759 // (6) == 16
10760 runString = "(6)";
10761 if (16 != jtt.optimize.Reduce_Int02.test(6)) {
10762 fail(runString);
10763 return;
10764 }
10765 // (7) == 17
10766 runString = "(7)";
10767 if (17 != jtt.optimize.Reduce_Int02.test(7)) {
10768 fail(runString);
10769 return;
10770 }
10771 } catch (Throwable t) {
10772 fail(runString, t);
10773 return;
10774 }
10775 pass();
10776 }
10777
10778 static void jtt_optimize_Reduce_Int03() {
10779 begin("jtt.optimize.Reduce_Int03");
10780 String runString = null;
10781 try {
10782 // (0) == 10
10783 runString = "(0)";
10784 if (10 != jtt.optimize.Reduce_Int03.test(0)) {
10785 fail(runString);
10786 return;
10787 }
10788 // (1) == 0
10789 runString = "(1)";
10790 if (0 != jtt.optimize.Reduce_Int03.test(1)) {
10791 fail(runString);
10792 return;
10793 }
10794 // (2) == 25
10795 runString = "(2)";
10796 if (25 != jtt.optimize.Reduce_Int03.test(2)) {
10797 fail(runString);
10798 return;
10799 }
10800 // (3) == 1
10801 runString = "(3)";
10802 if (1 != jtt.optimize.Reduce_Int03.test(3)) {
10803 fail(runString);
10804 return;
10805 }
10806 // (4) == 0
10807 runString = "(4)";
10808 if (0 != jtt.optimize.Reduce_Int03.test(4)) {
10809 fail(runString);
10810 return;
10811 }
10812 // (5) == 15
10813 runString = "(5)";
10814 if (15 != jtt.optimize.Reduce_Int03.test(5)) {
10815 fail(runString);
10816 return;
10817 }
10818 // (6) == 16
10819 runString = "(6)";
10820 if (16 != jtt.optimize.Reduce_Int03.test(6)) {
10821 fail(runString);
10822 return;
10823 }
10824 // (7) == 0
10825 runString = "(7)";
10826 if (0 != jtt.optimize.Reduce_Int03.test(7)) {
10827 fail(runString);
10828 return;
10829 }
10830 } catch (Throwable t) {
10831 fail(runString, t);
10832 return;
10833 }
10834 pass();
10835 }
10836
10837 static void jtt_optimize_Reduce_Int04() {
10838 begin("jtt.optimize.Reduce_Int04");
10839 String runString = null;
10840 try {
10841 // (0) == 40
10842 runString = "(0)";
10843 if (40 != jtt.optimize.Reduce_Int04.test(0)) {
10844 fail(runString);
10845 return;
10846 }
10847 // (1) == 655360
10848 runString = "(1)";
10849 if (655360 != jtt.optimize.Reduce_Int04.test(1)) {
10850 fail(runString);
10851 return;
10852 }
10853 } catch (Throwable t) {
10854 fail(runString, t);
10855 return;
10856 }
10857 pass();
10858 }
10859
10860 static void jtt_optimize_Reduce_IntShift01() {
10861 begin("jtt.optimize.Reduce_IntShift01");
10862 String runString = null;
10863 try {
10864 // (0) == 10
10865 runString = "(0)";
10866 if (10 != jtt.optimize.Reduce_IntShift01.test(0)) {
10867 fail(runString);
10868 return;
10869 }
10870 // (1) == 11
10871 runString = "(1)";
10872 if (11 != jtt.optimize.Reduce_IntShift01.test(1)) {
10873 fail(runString);
10874 return;
10875 }
10876 // (2) == 12
10877 runString = "(2)";
10878 if (12 != jtt.optimize.Reduce_IntShift01.test(2)) {
10879 fail(runString);
10880 return;
10881 }
10882 // (3) == 13
10883 runString = "(3)";
10884 if (13 != jtt.optimize.Reduce_IntShift01.test(3)) {
10885 fail(runString);
10886 return;
10887 }
10888 // (4) == 14
10889 runString = "(4)";
10890 if (14 != jtt.optimize.Reduce_IntShift01.test(4)) {
10891 fail(runString);
10892 return;
10893 }
10894 // (5) == 15
10895 runString = "(5)";
10896 if (15 != jtt.optimize.Reduce_IntShift01.test(5)) {
10897 fail(runString);
10898 return;
10899 }
10900 } catch (Throwable t) {
10901 fail(runString, t);
10902 return;
10903 }
10904 pass();
10905 }
10906
10907 static void jtt_optimize_Reduce_IntShift02() {
10908 begin("jtt.optimize.Reduce_IntShift02");
10909 String runString = null;
10910 try {
10911 // (0) == 80
10912 runString = "(0)";
10913 if (80 != jtt.optimize.Reduce_IntShift02.test(0)) {
10914 fail(runString);
10915 return;
10916 }
10917 // (1) == 11
10918 runString = "(1)";
10919 if (11 != jtt.optimize.Reduce_IntShift02.test(1)) {
10920 fail(runString);
10921 return;
10922 }
10923 // (2) == 12
10924 runString = "(2)";
10925 if (12 != jtt.optimize.Reduce_IntShift02.test(2)) {
10926 fail(runString);
10927 return;
10928 }
10929 // (3) == 13
10930 runString = "(3)";
10931 if (13 != jtt.optimize.Reduce_IntShift02.test(3)) {
10932 fail(runString);
10933 return;
10934 }
10935 // (4) == 64
10936 runString = "(4)";
10937 if (64 != jtt.optimize.Reduce_IntShift02.test(4)) {
10938 fail(runString);
10939 return;
10940 }
10941 } catch (Throwable t) {
10942 fail(runString, t);
10943 return;
10944 }
10945 pass();
10946 }
10947
10948 static void jtt_optimize_Reduce_Long01() {
10949 begin("jtt.optimize.Reduce_Long01");
10950 String runString = null;
10951 try {
10952 // (0) == 10
10953 runString = "(0)";
10954 if (10L != jtt.optimize.Reduce_Long01.test(0)) {
10955 fail(runString);
10956 return;
10957 }
10958 // (1) == 11
10959 runString = "(1)";
10960 if (11L != jtt.optimize.Reduce_Long01.test(1)) {
10961 fail(runString);
10962 return;
10963 }
10964 // (2) == 12
10965 runString = "(2)";
10966 if (12L != jtt.optimize.Reduce_Long01.test(2)) {
10967 fail(runString);
10968 return;
10969 }
10970 // (3) == 13
10971 runString = "(3)";
10972 if (13L != jtt.optimize.Reduce_Long01.test(3)) {
10973 fail(runString);
10974 return;
10975 }
10976 // (4) == 14
10977 runString = "(4)";
10978 if (14L != jtt.optimize.Reduce_Long01.test(4)) {
10979 fail(runString);
10980 return;
10981 }
10982 // (5) == 15
10983 runString = "(5)";
10984 if (15L != jtt.optimize.Reduce_Long01.test(5)) {
10985 fail(runString);
10986 return;
10987 }
10988 // (6) == 16
10989 runString = "(6)";
10990 if (16L != jtt.optimize.Reduce_Long01.test(6)) {
10991 fail(runString);
10992 return;
10993 }
10994 // (7) == 17
10995 runString = "(7)";
10996 if (17L != jtt.optimize.Reduce_Long01.test(7)) {
10997 fail(runString);
10998 return;
10999 }
11000 } catch (Throwable t) {
11001 fail(runString, t);
11002 return;
11003 }
11004 pass();
11005 }
11006
11007 static void jtt_optimize_Reduce_Long02() {
11008 begin("jtt.optimize.Reduce_Long02");
11009 String runString = null;
11010 try {
11011 // (0) == 10
11012 runString = "(0)";
11013 if (10L != jtt.optimize.Reduce_Long02.test(0)) {
11014 fail(runString);
11015 return;
11016 }
11017 // (1) == 11
11018 runString = "(1)";
11019 if (11L != jtt.optimize.Reduce_Long02.test(1)) {
11020 fail(runString);
11021 return;
11022 }
11023 // (2) == 12
11024 runString = "(2)";
11025 if (12L != jtt.optimize.Reduce_Long02.test(2)) {
11026 fail(runString);
11027 return;
11028 }
11029 // (3) == 13
11030 runString = "(3)";
11031 if (13L != jtt.optimize.Reduce_Long02.test(3)) {
11032 fail(runString);
11033 return;
11034 }
11035 // (4) == 14
11036 runString = "(4)";
11037 if (14L != jtt.optimize.Reduce_Long02.test(4)) {
11038 fail(runString);
11039 return;
11040 }
11041 // (5) == 15
11042 runString = "(5)";
11043 if (15L != jtt.optimize.Reduce_Long02.test(5)) {
11044 fail(runString);
11045 return;
11046 }
11047 // (6) == 16
11048 runString = "(6)";
11049 if (16L != jtt.optimize.Reduce_Long02.test(6)) {
11050 fail(runString);
11051 return;
11052 }
11053 // (7) == 17
11054 runString = "(7)";
11055 if (17L != jtt.optimize.Reduce_Long02.test(7)) {
11056 fail(runString);
11057 return;
11058 }
11059 } catch (Throwable t) {
11060 fail(runString, t);
11061 return;
11062 }
11063 pass();
11064 }
11065
11066 static void jtt_optimize_Reduce_Long03() {
11067 begin("jtt.optimize.Reduce_Long03");
11068 String runString = null;
11069 try {
11070 // (0) == 10
11071 runString = "(0)";
11072 if (10L != jtt.optimize.Reduce_Long03.test(0)) {
11073 fail(runString);
11074 return;
11075 }
11076 // (1) == 0
11077 runString = "(1)";
11078 if (0L != jtt.optimize.Reduce_Long03.test(1)) {
11079 fail(runString);
11080 return;
11081 }
11082 // (2) == 25
11083 runString = "(2)";
11084 if (25L != jtt.optimize.Reduce_Long03.test(2)) {
11085 fail(runString);
11086 return;
11087 }
11088 // (3) == 1
11089 runString = "(3)";
11090 if (1L != jtt.optimize.Reduce_Long03.test(3)) {
11091 fail(runString);
11092 return;
11093 }
11094 // (4) == 0
11095 runString = "(4)";
11096 if (0L != jtt.optimize.Reduce_Long03.test(4)) {
11097 fail(runString);
11098 return;
11099 }
11100 // (5) == 15
11101 runString = "(5)";
11102 if (15L != jtt.optimize.Reduce_Long03.test(5)) {
11103 fail(runString);
11104 return;
11105 }
11106 // (6) == 16
11107 runString = "(6)";
11108 if (16L != jtt.optimize.Reduce_Long03.test(6)) {
11109 fail(runString);
11110 return;
11111 }
11112 // (7) == 0
11113 runString = "(7)";
11114 if (0L != jtt.optimize.Reduce_Long03.test(7)) {
11115 fail(runString);
11116 return;
11117 }
11118 } catch (Throwable t) {
11119 fail(runString, t);
11120 return;
11121 }
11122 pass();
11123 }
11124
11125 static void jtt_optimize_Reduce_Long04() {
11126 begin("jtt.optimize.Reduce_Long04");
11127 String runString = null;
11128 try {
11129 // (0) == 40
11130 runString = "(0)";
11131 if (40L != jtt.optimize.Reduce_Long04.test(0)) {
11132 fail(runString);
11133 return;
11134 }
11135 // (1) == 85899345920
11136 runString = "(1)";
11137 if (85899345920L != jtt.optimize.Reduce_Long04.test(1)) {
11138 fail(runString);
11139 return;
11140 }
11141 } catch (Throwable t) {
11142 fail(runString, t);
11143 return;
11144 }
11145 pass();
11146 }
11147
11148 static void jtt_optimize_Reduce_LongShift01() {
11149 begin("jtt.optimize.Reduce_LongShift01");
11150 String runString = null;
11151 try {
11152 // (0) == 10
11153 runString = "(0)";
11154 if (10L != jtt.optimize.Reduce_LongShift01.test(0)) {
11155 fail(runString);
11156 return;
11157 }
11158 // (1) == 11
11159 runString = "(1)";
11160 if (11L != jtt.optimize.Reduce_LongShift01.test(1)) {
11161 fail(runString);
11162 return;
11163 }
11164 // (2) == 12
11165 runString = "(2)";
11166 if (12L != jtt.optimize.Reduce_LongShift01.test(2)) {
11167 fail(runString);
11168 return;
11169 }
11170 // (3) == 13
11171 runString = "(3)";
11172 if (13L != jtt.optimize.Reduce_LongShift01.test(3)) {
11173 fail(runString);
11174 return;
11175 }
11176 // (4) == 14
11177 runString = "(4)";
11178 if (14L != jtt.optimize.Reduce_LongShift01.test(4)) {
11179 fail(runString);
11180 return;
11181 }
11182 // (5) == 15
11183 runString = "(5)";
11184 if (15L != jtt.optimize.Reduce_LongShift01.test(5)) {
11185 fail(runString);
11186 return;
11187 }
11188 } catch (Throwable t) {
11189 fail(runString, t);
11190 return;
11191 }
11192 pass();
11193 }
11194
11195 static void jtt_optimize_Reduce_LongShift02() {
11196 begin("jtt.optimize.Reduce_LongShift02");
11197 String runString = null;
11198 try {
11199 // (0) == 80
11200 runString = "(0)";
11201 if (80L != jtt.optimize.Reduce_LongShift02.test(0)) {
11202 fail(runString);
11203 return;
11204 }
11205 // (1) == 11
11206 runString = "(1)";
11207 if (11L != jtt.optimize.Reduce_LongShift02.test(1)) {
11208 fail(runString);
11209 return;
11210 }
11211 // (2) == 12
11212 runString = "(2)";
11213 if (12L != jtt.optimize.Reduce_LongShift02.test(2)) {
11214 fail(runString);
11215 return;
11216 }
11217 // (3) == 13
11218 runString = "(3)";
11219 if (13L != jtt.optimize.Reduce_LongShift02.test(3)) {
11220 fail(runString);
11221 return;
11222 }
11223 // (4) == 64
11224 runString = "(4)";
11225 if (64L != jtt.optimize.Reduce_LongShift02.test(4)) {
11226 fail(runString);
11227 return;
11228 }
11229 } catch (Throwable t) {
11230 fail(runString, t);
11231 return;
11232 }
11233 pass();
11234 }
11235
11236 static void jtt_optimize_Switch01() {
11237 begin("jtt.optimize.Switch01");
11238 String runString = null;
11239 try {
11240 // (0) == 1
11241 runString = "(0)";
11242 if (1 != jtt.optimize.Switch01.test(0)) {
11243 fail(runString);
11244 return;
11245 }
11246 } catch (Throwable t) {
11247 fail(runString, t);
11248 return;
11249 }
11250 pass();
11251 }
11252
11253 static void jtt_optimize_Switch02() {
11254 begin("jtt.optimize.Switch02");
11255 String runString = null;
11256 try {
11257 // (0) == 1
11258 runString = "(0)";
11259 if (1 != jtt.optimize.Switch02.test(0)) {
11260 fail(runString);
11261 return;
11262 }
11263 // (1) == 2
11264 runString = "(1)";
11265 if (2 != jtt.optimize.Switch02.test(1)) {
11266 fail(runString);
11267 return;
11268 }
11269 } catch (Throwable t) {
11270 fail(runString, t);
11271 return;
11272 }
11273 pass();
11274 }
11275
11276 static void jtt_optimize_TypeCastElem() {
11277 begin("jtt.optimize.TypeCastElem");
11278 String runString = null;
11279 try {
11280 // (10,13,25) == 27183
11281 runString = "(10,13,25)";
11282 if (27183 != jtt.optimize.TypeCastElem.test(10, 13, 25)) {
11283 fail(runString);
11284 return;
11285 }
11286 } catch (Throwable t) {
11287 fail(runString, t);
11288 return;
11289 }
11290 pass();
11291 }
11292
11293 static void jtt_optimize_VN_Cast01() {
11294 begin("jtt.optimize.VN_Cast01");
11295 String runString = null;
11296 try {
11297 // (0) == 18
11298 runString = "(0)";
11299 if (18 != jtt.optimize.VN_Cast01.test(0)) {
11300 fail(runString);
11301 return;
11302 }
11303 // (1) == 18
11304 runString = "(1)";
11305 if (18 != jtt.optimize.VN_Cast01.test(1)) {
11306 fail(runString);
11307 return;
11308 }
11309 // (2) == !java.lang.NullPointerException
11310 try {
11311 runString = "(2)";
11312 jtt.optimize.VN_Cast01.test(2);
11313 fail(runString);
11314 return;
11315 } catch (Throwable e) {
11316 if (e.getClass() != java.lang.NullPointerException.class) {
11317 fail(runString, e);
11318 return;
11319 }
11320 }
11321 } catch (Throwable t) {
11322 fail(runString, t);
11323 return;
11324 }
11325 pass();
11326 }
11327
11328 static void jtt_optimize_VN_Cast02() {
11329 begin("jtt.optimize.VN_Cast02");
11330 String runString = null;
11331 try {
11332 // (0) == 18
11333 runString = "(0)";
11334 if (18 != jtt.optimize.VN_Cast02.test(0)) {
11335 fail(runString);
11336 return;
11337 }
11338 // (1) == 18
11339 runString = "(1)";
11340 if (18 != jtt.optimize.VN_Cast02.test(1)) {
11341 fail(runString);
11342 return;
11343 }
11344 // (2) == !java.lang.NullPointerException
11345 try {
11346 runString = "(2)";
11347 jtt.optimize.VN_Cast02.test(2);
11348 fail(runString);
11349 return;
11350 } catch (Throwable e) {
11351 if (e.getClass() != java.lang.NullPointerException.class) {
11352 fail(runString, e);
11353 return;
11354 }
11355 }
11356 } catch (Throwable t) {
11357 fail(runString, t);
11358 return;
11359 }
11360 pass();
11361 }
11362
11363 static void jtt_optimize_VN_Convert01() {
11364 begin("jtt.optimize.VN_Convert01");
11365 String runString = null;
11366 try {
11367 // (0) == 20
11368 runString = "(0)";
11369 if (20 != jtt.optimize.VN_Convert01.test(0)) {
11370 fail(runString);
11371 return;
11372 }
11373 // (1) == 22
11374 runString = "(1)";
11375 if (22 != jtt.optimize.VN_Convert01.test(1)) {
11376 fail(runString);
11377 return;
11378 }
11379 // (2) == 24
11380 runString = "(2)";
11381 if (24 != jtt.optimize.VN_Convert01.test(2)) {
11382 fail(runString);
11383 return;
11384 }
11385 } catch (Throwable t) {
11386 fail(runString, t);
11387 return;
11388 }
11389 pass();
11390 }
11391
11392 static void jtt_optimize_VN_Convert02() {
11393 begin("jtt.optimize.VN_Convert02");
11394 String runString = null;
11395 try {
11396 // (0) == 20
11397 runString = "(0)";
11398 if (20 != jtt.optimize.VN_Convert02.test(0)) {
11399 fail(runString);
11400 return;
11401 }
11402 // (1) == 22
11403 runString = "(1)";
11404 if (22 != jtt.optimize.VN_Convert02.test(1)) {
11405 fail(runString);
11406 return;
11407 }
11408 // (2) == 24
11409 runString = "(2)";
11410 if (24 != jtt.optimize.VN_Convert02.test(2)) {
11411 fail(runString);
11412 return;
11413 }
11414 } catch (Throwable t) {
11415 fail(runString, t);
11416 return;
11417 }
11418 pass();
11419 }
11420
11421 static void jtt_optimize_VN_Double01() {
11422 begin("jtt.optimize.VN_Double01");
11423 String runString = null;
11424 try {
11425 // (0.0) == 22.0
11426 runString = "(0.0)";
11427 if (22.0 != jtt.optimize.VN_Double01.test(0.0)) {
11428 fail(runString);
11429 return;
11430 }
11431 // (1.0) == 0.0
11432 runString = "(1.0)";
11433 if (0.0 != jtt.optimize.VN_Double01.test(1.0)) {
11434 fail(runString);
11435 return;
11436 }
11437 // (2.0) == 144.0
11438 runString = "(2.0)";
11439 if (144.0 != jtt.optimize.VN_Double01.test(2.0)) {
11440 fail(runString);
11441 return;
11442 }
11443 // (3.0) == 1.0
11444 runString = "(3.0)";
11445 if (1.0 != jtt.optimize.VN_Double01.test(3.0)) {
11446 fail(runString);
11447 return;
11448 }
11449 } catch (Throwable t) {
11450 fail(runString, t);
11451 return;
11452 }
11453 pass();
11454 }
11455
11456 static void jtt_optimize_VN_Double02() {
11457 begin("jtt.optimize.VN_Double02");
11458 String runString = null;
11459 try {
11460 // (0.0) == 22.0
11461 runString = "(0.0)";
11462 if (22.0 != jtt.optimize.VN_Double02.test(0.0)) {
11463 fail(runString);
11464 return;
11465 }
11466 // (1.0) == 0.0
11467 runString = "(1.0)";
11468 if (0.0 != jtt.optimize.VN_Double02.test(1.0)) {
11469 fail(runString);
11470 return;
11471 }
11472 // (2.0) == 144.0
11473 runString = "(2.0)";
11474 if (144.0 != jtt.optimize.VN_Double02.test(2.0)) {
11475 fail(runString);
11476 return;
11477 }
11478 // (3.0) == 1.0
11479 runString = "(3.0)";
11480 if (1.0 != jtt.optimize.VN_Double02.test(3.0)) {
11481 fail(runString);
11482 return;
11483 }
11484 } catch (Throwable t) {
11485 fail(runString, t);
11486 return;
11487 }
11488 pass();
11489 }
11490
11491 static void jtt_optimize_VN_Field01() {
11492 begin("jtt.optimize.VN_Field01");
11493 String runString = null;
11494 try {
11495 // (0) == 18
11496 runString = "(0)";
11497 if (18 != jtt.optimize.VN_Field01.test(0)) {
11498 fail(runString);
11499 return;
11500 }
11501 // (1) == 18
11502 runString = "(1)";
11503 if (18 != jtt.optimize.VN_Field01.test(1)) {
11504 fail(runString);
11505 return;
11506 }
11507 // (2) == !java.lang.NullPointerException
11508 try {
11509 runString = "(2)";
11510 jtt.optimize.VN_Field01.test(2);
11511 fail(runString);
11512 return;
11513 } catch (Throwable e) {
11514 if (e.getClass() != java.lang.NullPointerException.class) {
11515 fail(runString, e);
11516 return;
11517 }
11518 }
11519 } catch (Throwable t) {
11520 fail(runString, t);
11521 return;
11522 }
11523 pass();
11524 }
11525
11526 static void jtt_optimize_VN_Field02() {
11527 begin("jtt.optimize.VN_Field02");
11528 String runString = null;
11529 try {
11530 // (0) == 18
11531 runString = "(0)";
11532 if (18 != jtt.optimize.VN_Field02.test(0)) {
11533 fail(runString);
11534 return;
11535 }
11536 // (1) == 18
11537 runString = "(1)";
11538 if (18 != jtt.optimize.VN_Field02.test(1)) {
11539 fail(runString);
11540 return;
11541 }
11542 // (2) == !java.lang.NullPointerException
11543 try {
11544 runString = "(2)";
11545 jtt.optimize.VN_Field02.test(2);
11546 fail(runString);
11547 return;
11548 } catch (Throwable e) {
11549 if (e.getClass() != java.lang.NullPointerException.class) {
11550 fail(runString, e);
11551 return;
11552 }
11553 }
11554 } catch (Throwable t) {
11555 fail(runString, t);
11556 return;
11557 }
11558 pass();
11559 }
11560
11561 static void jtt_optimize_VN_Float01() {
11562 begin("jtt.optimize.VN_Float01");
11563 String runString = null;
11564 try {
11565 // (0.0) == 22.0
11566 runString = "(0.0)";
11567 if (22.0f != jtt.optimize.VN_Float01.test(0.0f)) {
11568 fail(runString);
11569 return;
11570 }
11571 // (1.0) == 0.0
11572 runString = "(1.0)";
11573 if (0.0f != jtt.optimize.VN_Float01.test(1.0f)) {
11574 fail(runString);
11575 return;
11576 }
11577 // (2.0) == 144.0
11578 runString = "(2.0)";
11579 if (144.0f != jtt.optimize.VN_Float01.test(2.0f)) {
11580 fail(runString);
11581 return;
11582 }
11583 // (3.0) == 1.0
11584 runString = "(3.0)";
11585 if (1.0f != jtt.optimize.VN_Float01.test(3.0f)) {
11586 fail(runString);
11587 return;
11588 }
11589 } catch (Throwable t) {
11590 fail(runString, t);
11591 return;
11592 }
11593 pass();
11594 }
11595
11596 static void jtt_optimize_VN_Float02() {
11597 begin("jtt.optimize.VN_Float02");
11598 String runString = null;
11599 try {
11600 // (0.0) == 22.0
11601 runString = "(0.0)";
11602 if (22.0f != jtt.optimize.VN_Float02.test(0.0f)) {
11603 fail(runString);
11604 return;
11605 }
11606 // (1.0) == 0.0
11607 runString = "(1.0)";
11608 if (0.0f != jtt.optimize.VN_Float02.test(1.0f)) {
11609 fail(runString);
11610 return;
11611 }
11612 // (2.0) == 144.0
11613 runString = "(2.0)";
11614 if (144.0f != jtt.optimize.VN_Float02.test(2.0f)) {
11615 fail(runString);
11616 return;
11617 }
11618 // (3.0) == 1.0
11619 runString = "(3.0)";
11620 if (1.0f != jtt.optimize.VN_Float02.test(3.0f)) {
11621 fail(runString);
11622 return;
11623 }
11624 } catch (Throwable t) {
11625 fail(runString, t);
11626 return;
11627 }
11628 pass();
11629 }
11630
11631 static void jtt_optimize_VN_InstanceOf01() {
11632 begin("jtt.optimize.VN_InstanceOf01");
11633 String runString = null;
11634 try {
11635 // (0) == true
11636 runString = "(0)";
11637 if (true != jtt.optimize.VN_InstanceOf01.test(0)) {
11638 fail(runString);
11639 return;
11640 }
11641 // (1) == true
11642 runString = "(1)";
11643 if (true != jtt.optimize.VN_InstanceOf01.test(1)) {
11644 fail(runString);
11645 return;
11646 }
11647 // (2) == false
11648 runString = "(2)";
11649 if (false != jtt.optimize.VN_InstanceOf01.test(2)) {
11650 fail(runString);
11651 return;
11652 }
11653 } catch (Throwable t) {
11654 fail(runString, t);
11655 return;
11656 }
11657 pass();
11658 }
11659
11660 static void jtt_optimize_VN_InstanceOf02() {
11661 begin("jtt.optimize.VN_InstanceOf02");
11662 String runString = null;
11663 try {
11664 // (0) == true
11665 runString = "(0)";
11666 if (true != jtt.optimize.VN_InstanceOf02.test(0)) {
11667 fail(runString);
11668 return;
11669 }
11670 // (1) == true
11671 runString = "(1)";
11672 if (true != jtt.optimize.VN_InstanceOf02.test(1)) {
11673 fail(runString);
11674 return;
11675 }
11676 // (2) == false
11677 runString = "(2)";
11678 if (false != jtt.optimize.VN_InstanceOf02.test(2)) {
11679 fail(runString);
11680 return;
11681 }
11682 } catch (Throwable t) {
11683 fail(runString, t);
11684 return;
11685 }
11686 pass();
11687 }
11688
11689 static void jtt_optimize_VN_InstanceOf03() {
11690 begin("jtt.optimize.VN_InstanceOf03");
11691 String runString = null;
11692 try {
11693 // (0) == true
11694 runString = "(0)";
11695 if (true != jtt.optimize.VN_InstanceOf03.test(0)) {
11696 fail(runString);
11697 return;
11698 }
11699 // (1) == true
11700 runString = "(1)";
11701 if (true != jtt.optimize.VN_InstanceOf03.test(1)) {
11702 fail(runString);
11703 return;
11704 }
11705 // (2) == true
11706 runString = "(2)";
11707 if (true != jtt.optimize.VN_InstanceOf03.test(2)) {
11708 fail(runString);
11709 return;
11710 }
11711 } catch (Throwable t) {
11712 fail(runString, t);
11713 return;
11714 }
11715 pass();
11716 }
11717
11718 static void jtt_optimize_VN_Int01() {
11719 begin("jtt.optimize.VN_Int01");
11720 String runString = null;
11721 try {
11722 // (0) == 6
11723 runString = "(0)";
11724 if (6 != jtt.optimize.VN_Int01.test(0)) {
11725 fail(runString);
11726 return;
11727 }
11728 // (1) == 0
11729 runString = "(1)";
11730 if (0 != jtt.optimize.VN_Int01.test(1)) {
11731 fail(runString);
11732 return;
11733 }
11734 // (2) == 36
11735 runString = "(2)";
11736 if (36 != jtt.optimize.VN_Int01.test(2)) {
11737 fail(runString);
11738 return;
11739 }
11740 // (3) == 1
11741 runString = "(3)";
11742 if (1 != jtt.optimize.VN_Int01.test(3)) {
11743 fail(runString);
11744 return;
11745 }
11746 // (4) == 0
11747 runString = "(4)";
11748 if (0 != jtt.optimize.VN_Int01.test(4)) {
11749 fail(runString);
11750 return;
11751 }
11752 // (5) == 5
11753 runString = "(5)";
11754 if (5 != jtt.optimize.VN_Int01.test(5)) {
11755 fail(runString);
11756 return;
11757 }
11758 // (6) == 7
11759 runString = "(6)";
11760 if (7 != jtt.optimize.VN_Int01.test(6)) {
11761 fail(runString);
11762 return;
11763 }
11764 // (7) == 0
11765 runString = "(7)";
11766 if (0 != jtt.optimize.VN_Int01.test(7)) {
11767 fail(runString);
11768 return;
11769 }
11770 } catch (Throwable t) {
11771 fail(runString, t);
11772 return;
11773 }
11774 pass();
11775 }
11776
11777 static void jtt_optimize_VN_Int02() {
11778 begin("jtt.optimize.VN_Int02");
11779 String runString = null;
11780 try {
11781 // (0) == 10
11782 runString = "(0)";
11783 if (10 != jtt.optimize.VN_Int02.test(0)) {
11784 fail(runString);
11785 return;
11786 }
11787 // (1) == 10
11788 runString = "(1)";
11789 if (10 != jtt.optimize.VN_Int02.test(1)) {
11790 fail(runString);
11791 return;
11792 }
11793 // (2) == 48
11794 runString = "(2)";
11795 if (48 != jtt.optimize.VN_Int02.test(2)) {
11796 fail(runString);
11797 return;
11798 }
11799 } catch (Throwable t) {
11800 fail(runString, t);
11801 return;
11802 }
11803 pass();
11804 }
11805
11806 static void jtt_optimize_VN_Int03() {
11807 begin("jtt.optimize.VN_Int03");
11808 String runString = null;
11809 try {
11810 // (0) == 6
11811 runString = "(0)";
11812 if (6 != jtt.optimize.VN_Int03.test(0)) {
11813 fail(runString);
11814 return;
11815 }
11816 // (1) == 0
11817 runString = "(1)";
11818 if (0 != jtt.optimize.VN_Int03.test(1)) {
11819 fail(runString);
11820 return;
11821 }
11822 // (2) == 36
11823 runString = "(2)";
11824 if (36 != jtt.optimize.VN_Int03.test(2)) {
11825 fail(runString);
11826 return;
11827 }
11828 // (3) == 1
11829 runString = "(3)";
11830 if (1 != jtt.optimize.VN_Int03.test(3)) {
11831 fail(runString);
11832 return;
11833 }
11834 // (4) == 0
11835 runString = "(4)";
11836 if (0 != jtt.optimize.VN_Int03.test(4)) {
11837 fail(runString);
11838 return;
11839 }
11840 // (5) == 5
11841 runString = "(5)";
11842 if (5 != jtt.optimize.VN_Int03.test(5)) {
11843 fail(runString);
11844 return;
11845 }
11846 // (6) == 7
11847 runString = "(6)";
11848 if (7 != jtt.optimize.VN_Int03.test(6)) {
11849 fail(runString);
11850 return;
11851 }
11852 // (7) == 0
11853 runString = "(7)";
11854 if (0 != jtt.optimize.VN_Int03.test(7)) {
11855 fail(runString);
11856 return;
11857 }
11858 } catch (Throwable t) {
11859 fail(runString, t);
11860 return;
11861 }
11862 pass();
11863 }
11864
11865 static void jtt_optimize_VN_Long01() {
11866 begin("jtt.optimize.VN_Long01");
11867 String runString = null;
11868 try {
11869 // (0) == 6
11870 runString = "(0)";
11871 if (6L != jtt.optimize.VN_Long01.test(0)) {
11872 fail(runString);
11873 return;
11874 }
11875 // (1) == 0
11876 runString = "(1)";
11877 if (0L != jtt.optimize.VN_Long01.test(1)) {
11878 fail(runString);
11879 return;
11880 }
11881 // (2) == 36
11882 runString = "(2)";
11883 if (36L != jtt.optimize.VN_Long01.test(2)) {
11884 fail(runString);
11885 return;
11886 }
11887 // (3) == 1
11888 runString = "(3)";
11889 if (1L != jtt.optimize.VN_Long01.test(3)) {
11890 fail(runString);
11891 return;
11892 }
11893 // (4) == 0
11894 runString = "(4)";
11895 if (0L != jtt.optimize.VN_Long01.test(4)) {
11896 fail(runString);
11897 return;
11898 }
11899 // (5) == 5
11900 runString = "(5)";
11901 if (5L != jtt.optimize.VN_Long01.test(5)) {
11902 fail(runString);
11903 return;
11904 }
11905 // (6) == 7
11906 runString = "(6)";
11907 if (7L != jtt.optimize.VN_Long01.test(6)) {
11908 fail(runString);
11909 return;
11910 }
11911 // (7) == 0
11912 runString = "(7)";
11913 if (0L != jtt.optimize.VN_Long01.test(7)) {
11914 fail(runString);
11915 return;
11916 }
11917 } catch (Throwable t) {
11918 fail(runString, t);
11919 return;
11920 }
11921 pass();
11922 }
11923
11924 static void jtt_optimize_VN_Long02() {
11925 begin("jtt.optimize.VN_Long02");
11926 String runString = null;
11927 try {
11928 // (0) == 10
11929 runString = "(0)";
11930 if (10L != jtt.optimize.VN_Long02.test(0)) {
11931 fail(runString);
11932 return;
11933 }
11934 // (1) == 10
11935 runString = "(1)";
11936 if (10L != jtt.optimize.VN_Long02.test(1)) {
11937 fail(runString);
11938 return;
11939 }
11940 // (2) == 48
11941 runString = "(2)";
11942 if (48L != jtt.optimize.VN_Long02.test(2)) {
11943 fail(runString);
11944 return;
11945 }
11946 } catch (Throwable t) {
11947 fail(runString, t);
11948 return;
11949 }
11950 pass();
11951 }
11952
11953 static void jtt_optimize_VN_Long03() {
11954 begin("jtt.optimize.VN_Long03");
11955 String runString = null;
11956 try {
11957 // (0) == 6
11958 runString = "(0)";
11959 if (6L != jtt.optimize.VN_Long03.test(0)) {
11960 fail(runString);
11961 return;
11962 }
11963 // (1) == 0
11964 runString = "(1)";
11965 if (0L != jtt.optimize.VN_Long03.test(1)) {
11966 fail(runString);
11967 return;
11968 }
11969 // (2) == 36
11970 runString = "(2)";
11971 if (36L != jtt.optimize.VN_Long03.test(2)) {
11972 fail(runString);
11973 return;
11974 }
11975 // (3) == 1
11976 runString = "(3)";
11977 if (1L != jtt.optimize.VN_Long03.test(3)) {
11978 fail(runString);
11979 return;
11980 }
11981 // (4) == 0
11982 runString = "(4)";
11983 if (0L != jtt.optimize.VN_Long03.test(4)) {
11984 fail(runString);
11985 return;
11986 }
11987 // (5) == 5
11988 runString = "(5)";
11989 if (5L != jtt.optimize.VN_Long03.test(5)) {
11990 fail(runString);
11991 return;
11992 }
11993 // (6) == 7
11994 runString = "(6)";
11995 if (7L != jtt.optimize.VN_Long03.test(6)) {
11996 fail(runString);
11997 return;
11998 }
11999 // (7) == 0
12000 runString = "(7)";
12001 if (0L != jtt.optimize.VN_Long03.test(7)) {
12002 fail(runString);
12003 return;
12004 }
12005 } catch (Throwable t) {
12006 fail(runString, t);
12007 return;
12008 }
12009 pass();
12010 }
12011
12012 static void jtt_optimize_VN_Loop01() {
12013 begin("jtt.optimize.VN_Loop01");
12014 String runString = null;
12015 try {
12016 // (0) == 6
12017 runString = "(0)";
12018 if (6 != jtt.optimize.VN_Loop01.test(0)) {
12019 fail(runString);
12020 return;
12021 }
12022 // (1) == 8
12023 runString = "(1)";
12024 if (8 != jtt.optimize.VN_Loop01.test(1)) {
12025 fail(runString);
12026 return;
12027 }
12028 // (2) == 10
12029 runString = "(2)";
12030 if (10 != jtt.optimize.VN_Loop01.test(2)) {
12031 fail(runString);
12032 return;
12033 }
12034 // (3) == 12
12035 runString = "(3)";
12036 if (12 != jtt.optimize.VN_Loop01.test(3)) {
12037 fail(runString);
12038 return;
12039 }
12040 // (4) == 0
12041 runString = "(4)";
12042 if (0 != jtt.optimize.VN_Loop01.test(4)) {
12043 fail(runString);
12044 return;
12045 }
12046 } catch (Throwable t) {
12047 fail(runString, t);
12048 return;
12049 }
12050 pass();
12051 }
12052
12053 static void jtt_except_BC_aaload0() {
12054 begin("jtt.except.BC_aaload0");
12055 String runString = null;
12056 try {
12057 // (-2) == !java.lang.NullPointerException
12058 try {
12059 runString = "(-2)";
12060 jtt.except.BC_aaload0.test(-2);
12061 fail(runString);
12062 return;
12063 } catch (Throwable e) {
12064 if (e.getClass() != java.lang.NullPointerException.class) {
12065 fail(runString, e);
12066 return;
12067 }
12068 }
12069 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
12070 try {
12071 runString = "(-1)";
12072 jtt.except.BC_aaload0.test(-1);
12073 fail(runString);
12074 return;
12075 } catch (Throwable e) {
12076 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12077 fail(runString, e);
12078 return;
12079 }
12080 }
12081 // (0) == null
12082 runString = "(0)";
12083 if (null != jtt.except.BC_aaload0.test(0)) {
12084 fail(runString);
12085 return;
12086 }
12087 } catch (Throwable t) {
12088 fail(runString, t);
12089 return;
12090 }
12091 pass();
12092 }
12093
12094 static void jtt_except_BC_aaload1() {
12095 begin("jtt.except.BC_aaload1");
12096 String runString = null;
12097 try {
12098 // (-2) == null
12099 runString = "(-2)";
12100 if (null != jtt.except.BC_aaload1.test(-2)) {
12101 fail(runString);
12102 return;
12103 }
12104 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
12105 try {
12106 runString = "(-1)";
12107 jtt.except.BC_aaload1.test(-1);
12108 fail(runString);
12109 return;
12110 } catch (Throwable e) {
12111 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12112 fail(runString, e);
12113 return;
12114 }
12115 }
12116 // (0) == null
12117 runString = "(0)";
12118 if (null != jtt.except.BC_aaload1.test(0)) {
12119 fail(runString);
12120 return;
12121 }
12122 } catch (Throwable t) {
12123 fail(runString, t);
12124 return;
12125 }
12126 pass();
12127 }
12128
12129 static void jtt_except_BC_aastore0() {
12130 begin("jtt.except.BC_aastore0");
12131 String runString = null;
12132 try {
12133 // (true,-2) == !java.lang.NullPointerException
12134 try {
12135 runString = "(true,-2)";
12136 jtt.except.BC_aastore0.test(true, -2);
12137 fail(runString);
12138 return;
12139 } catch (Throwable e) {
12140 if (e.getClass() != java.lang.NullPointerException.class) {
12141 fail(runString, e);
12142 return;
12143 }
12144 }
12145 // (true,-1) == !java.lang.ArrayIndexOutOfBoundsException
12146 try {
12147 runString = "(true,-1)";
12148 jtt.except.BC_aastore0.test(true, -1);
12149 fail(runString);
12150 return;
12151 } catch (Throwable e) {
12152 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12153 fail(runString, e);
12154 return;
12155 }
12156 }
12157 // (true,0) == 0
12158 runString = "(true,0)";
12159 if (0 != jtt.except.BC_aastore0.test(true, 0)) {
12160 fail(runString);
12161 return;
12162 }
12163 // (true,1) == 1
12164 runString = "(true,1)";
12165 if (1 != jtt.except.BC_aastore0.test(true, 1)) {
12166 fail(runString);
12167 return;
12168 }
12169 // (true,2) == 2
12170 runString = "(true,2)";
12171 if (2 != jtt.except.BC_aastore0.test(true, 2)) {
12172 fail(runString);
12173 return;
12174 }
12175 // (true,3) == !java.lang.ArrayIndexOutOfBoundsException
12176 try {
12177 runString = "(true,3)";
12178 jtt.except.BC_aastore0.test(true, 3);
12179 fail(runString);
12180 return;
12181 } catch (Throwable e) {
12182 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12183 fail(runString, e);
12184 return;
12185 }
12186 }
12187 // (false,0) == !java.lang.ArrayStoreException
12188 try {
12189 runString = "(false,0)";
12190 jtt.except.BC_aastore0.test(false, 0);
12191 fail(runString);
12192 return;
12193 } catch (Throwable e) {
12194 if (e.getClass() != java.lang.ArrayStoreException.class) {
12195 fail(runString, e);
12196 return;
12197 }
12198 }
12199 // (false,1) == 1
12200 runString = "(false,1)";
12201 if (1 != jtt.except.BC_aastore0.test(false, 1)) {
12202 fail(runString);
12203 return;
12204 }
12205 // (false,2) == 2
12206 runString = "(false,2)";
12207 if (2 != jtt.except.BC_aastore0.test(false, 2)) {
12208 fail(runString);
12209 return;
12210 }
12211 // (false,3) == !java.lang.ArrayIndexOutOfBoundsException
12212 try {
12213 runString = "(false,3)";
12214 jtt.except.BC_aastore0.test(false, 3);
12215 fail(runString);
12216 return;
12217 } catch (Throwable e) {
12218 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12219 fail(runString, e);
12220 return;
12221 }
12222 }
12223 } catch (Throwable t) {
12224 fail(runString, t);
12225 return;
12226 }
12227 pass();
12228 }
12229
12230 static void jtt_except_BC_aastore1() {
12231 begin("jtt.except.BC_aastore1");
12232 String runString = null;
12233 try {
12234 // (true,-2) == 5
12235 runString = "(true,-2)";
12236 if (5 != jtt.except.BC_aastore1.test(true, -2)) {
12237 fail(runString);
12238 return;
12239 }
12240 // (true,-1) == !java.lang.ArrayIndexOutOfBoundsException
12241 try {
12242 runString = "(true,-1)";
12243 jtt.except.BC_aastore1.test(true, -1);
12244 fail(runString);
12245 return;
12246 } catch (Throwable e) {
12247 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12248 fail(runString, e);
12249 return;
12250 }
12251 }
12252 // (true,0) == 0
12253 runString = "(true,0)";
12254 if (0 != jtt.except.BC_aastore1.test(true, 0)) {
12255 fail(runString);
12256 return;
12257 }
12258 // (true,1) == 1
12259 runString = "(true,1)";
12260 if (1 != jtt.except.BC_aastore1.test(true, 1)) {
12261 fail(runString);
12262 return;
12263 }
12264 // (true,2) == 2
12265 runString = "(true,2)";
12266 if (2 != jtt.except.BC_aastore1.test(true, 2)) {
12267 fail(runString);
12268 return;
12269 }
12270 // (true,3) == !java.lang.ArrayIndexOutOfBoundsException
12271 try {
12272 runString = "(true,3)";
12273 jtt.except.BC_aastore1.test(true, 3);
12274 fail(runString);
12275 return;
12276 } catch (Throwable e) {
12277 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12278 fail(runString, e);
12279 return;
12280 }
12281 }
12282 // (false,0) == !java.lang.ArrayStoreException
12283 try {
12284 runString = "(false,0)";
12285 jtt.except.BC_aastore1.test(false, 0);
12286 fail(runString);
12287 return;
12288 } catch (Throwable e) {
12289 if (e.getClass() != java.lang.ArrayStoreException.class) {
12290 fail(runString, e);
12291 return;
12292 }
12293 }
12294 // (false,1) == 1
12295 runString = "(false,1)";
12296 if (1 != jtt.except.BC_aastore1.test(false, 1)) {
12297 fail(runString);
12298 return;
12299 }
12300 // (false,2) == 2
12301 runString = "(false,2)";
12302 if (2 != jtt.except.BC_aastore1.test(false, 2)) {
12303 fail(runString);
12304 return;
12305 }
12306 // (false,3) == !java.lang.ArrayIndexOutOfBoundsException
12307 try {
12308 runString = "(false,3)";
12309 jtt.except.BC_aastore1.test(false, 3);
12310 fail(runString);
12311 return;
12312 } catch (Throwable e) {
12313 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12314 fail(runString, e);
12315 return;
12316 }
12317 }
12318 } catch (Throwable t) {
12319 fail(runString, t);
12320 return;
12321 }
12322 pass();
12323 }
12324
12325 static void jtt_except_BC_anewarray() {
12326 begin("jtt.except.BC_anewarray");
12327 String runString = null;
12328 try {
12329 // (-1) == !java.lang.NegativeArraySizeException
12330 try {
12331 runString = "(-1)";
12332 jtt.except.BC_anewarray.test(-1);
12333 fail(runString);
12334 return;
12335 } catch (Throwable e) {
12336 if (e.getClass() != java.lang.NegativeArraySizeException.class) {
12337 fail(runString, e);
12338 return;
12339 }
12340 }
12341 // (1) == 1
12342 runString = "(1)";
12343 if (1 != jtt.except.BC_anewarray.test(1)) {
12344 fail(runString);
12345 return;
12346 }
12347 } catch (Throwable t) {
12348 fail(runString, t);
12349 return;
12350 }
12351 pass();
12352 }
12353
12354 static void jtt_except_BC_arraylength() {
12355 begin("jtt.except.BC_arraylength");
12356 String runString = null;
12357 try {
12358 // (0) == !java.lang.NullPointerException
12359 try {
12360 runString = "(0)";
12361 jtt.except.BC_arraylength.test(0);
12362 fail(runString);
12363 return;
12364 } catch (Throwable e) {
12365 if (e.getClass() != java.lang.NullPointerException.class) {
12366 fail(runString, e);
12367 return;
12368 }
12369 }
12370 // (1) == 3
12371 runString = "(1)";
12372 if (3 != jtt.except.BC_arraylength.test(1)) {
12373 fail(runString);
12374 return;
12375 }
12376 // (2) == 4
12377 runString = "(2)";
12378 if (4 != jtt.except.BC_arraylength.test(2)) {
12379 fail(runString);
12380 return;
12381 }
12382 // (3) == 5
12383 runString = "(3)";
12384 if (5 != jtt.except.BC_arraylength.test(3)) {
12385 fail(runString);
12386 return;
12387 }
12388 // (4) == 42
12389 runString = "(4)";
12390 if (42 != jtt.except.BC_arraylength.test(4)) {
12391 fail(runString);
12392 return;
12393 }
12394 } catch (Throwable t) {
12395 fail(runString, t);
12396 return;
12397 }
12398 pass();
12399 }
12400
12401 static void jtt_except_BC_athrow0() {
12402 begin("jtt.except.BC_athrow0");
12403 String runString = null;
12404 try {
12405 // (0) == 0
12406 runString = "(0)";
12407 if (0 != jtt.except.BC_athrow0.test(0)) {
12408 fail(runString);
12409 return;
12410 }
12411 // (2) == !java.lang.Throwable
12412 try {
12413 runString = "(2)";
12414 jtt.except.BC_athrow0.test(2);
12415 fail(runString);
12416 return;
12417 } catch (Throwable e) {
12418 if (e.getClass() != java.lang.Throwable.class) {
12419 fail(runString, e);
12420 return;
12421 }
12422 }
12423 } catch (Throwable t) {
12424 fail(runString, t);
12425 return;
12426 }
12427 pass();
12428 }
12429
12430 static void jtt_except_BC_athrow1() {
12431 begin("jtt.except.BC_athrow1");
12432 String runString = null;
12433 try {
12434 // (0) == 0
12435 runString = "(0)";
12436 if (0 != jtt.except.BC_athrow1.test(0)) {
12437 fail(runString);
12438 return;
12439 }
12440 // (1) == 1
12441 runString = "(1)";
12442 if (1 != jtt.except.BC_athrow1.test(1)) {
12443 fail(runString);
12444 return;
12445 }
12446 // (2) == !java.lang.Throwable
12447 try {
12448 runString = "(2)";
12449 jtt.except.BC_athrow1.test(2);
12450 fail(runString);
12451 return;
12452 } catch (Throwable e) {
12453 if (e.getClass() != java.lang.Throwable.class) {
12454 fail(runString, e);
12455 return;
12456 }
12457 }
12458 // (3) == 3
12459 runString = "(3)";
12460 if (3 != jtt.except.BC_athrow1.test(3)) {
12461 fail(runString);
12462 return;
12463 }
12464 } catch (Throwable t) {
12465 fail(runString, t);
12466 return;
12467 }
12468 pass();
12469 }
12470
12471 static void jtt_except_BC_athrow2() {
12472 begin("jtt.except.BC_athrow2");
12473 String runString = null;
12474 try {
12475 // (0) == 0
12476 runString = "(0)";
12477 if (0 != jtt.except.BC_athrow2.test(0)) {
12478 fail(runString);
12479 return;
12480 }
12481 // (2) == !java.lang.Throwable
12482 try {
12483 runString = "(2)";
12484 jtt.except.BC_athrow2.test(2);
12485 fail(runString);
12486 return;
12487 } catch (Throwable e) {
12488 if (e.getClass() != java.lang.Throwable.class) {
12489 fail(runString, e);
12490 return;
12491 }
12492 }
12493 // (3) == !java.lang.NullPointerException
12494 try {
12495 runString = "(3)";
12496 jtt.except.BC_athrow2.test(3);
12497 fail(runString);
12498 return;
12499 } catch (Throwable e) {
12500 if (e.getClass() != java.lang.NullPointerException.class) {
12501 fail(runString, e);
12502 return;
12503 }
12504 }
12505 } catch (Throwable t) {
12506 fail(runString, t);
12507 return;
12508 }
12509 pass();
12510 }
12511
12512 static void jtt_except_BC_athrow3() {
12513 begin("jtt.except.BC_athrow3");
12514 String runString = null;
12515 try {
12516 // (0) == 0
12517 runString = "(0)";
12518 if (0 != jtt.except.BC_athrow3.test(0)) {
12519 fail(runString);
12520 return;
12521 }
12522 // (2) == !java.lang.Throwable
12523 try {
12524 runString = "(2)";
12525 jtt.except.BC_athrow3.test(2);
12526 fail(runString);
12527 return;
12528 } catch (Throwable e) {
12529 if (e.getClass() != java.lang.Throwable.class) {
12530 fail(runString, e);
12531 return;
12532 }
12533 }
12534 // (3) == !java.lang.NullPointerException
12535 try {
12536 runString = "(3)";
12537 jtt.except.BC_athrow3.test(3);
12538 fail(runString);
12539 return;
12540 } catch (Throwable e) {
12541 if (e.getClass() != java.lang.NullPointerException.class) {
12542 fail(runString, e);
12543 return;
12544 }
12545 }
12546 } catch (Throwable t) {
12547 fail(runString, t);
12548 return;
12549 }
12550 pass();
12551 }
12552
12553 static void jtt_except_BC_baload() {
12554 begin("jtt.except.BC_baload");
12555 String runString = null;
12556 try {
12557 // (-2) == !java.lang.NullPointerException
12558 try {
12559 runString = "(-2)";
12560 jtt.except.BC_baload.test(-2);
12561 fail(runString);
12562 return;
12563 } catch (Throwable e) {
12564 if (e.getClass() != java.lang.NullPointerException.class) {
12565 fail(runString, e);
12566 return;
12567 }
12568 }
12569 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
12570 try {
12571 runString = "(-1)";
12572 jtt.except.BC_baload.test(-1);
12573 fail(runString);
12574 return;
12575 } catch (Throwable e) {
12576 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12577 fail(runString, e);
12578 return;
12579 }
12580 }
12581 // (0) == true
12582 runString = "(0)";
12583 if (true != jtt.except.BC_baload.test(0)) {
12584 fail(runString);
12585 return;
12586 }
12587 // (4) == !java.lang.ArrayIndexOutOfBoundsException
12588 try {
12589 runString = "(4)";
12590 jtt.except.BC_baload.test(4);
12591 fail(runString);
12592 return;
12593 } catch (Throwable e) {
12594 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12595 fail(runString, e);
12596 return;
12597 }
12598 }
12599 } catch (Throwable t) {
12600 fail(runString, t);
12601 return;
12602 }
12603 pass();
12604 }
12605
12606 static void jtt_except_BC_bastore() {
12607 begin("jtt.except.BC_bastore");
12608 String runString = null;
12609 try {
12610 // (-2,true) == !java.lang.NullPointerException
12611 try {
12612 runString = "(-2,true)";
12613 jtt.except.BC_bastore.test(-2, true);
12614 fail(runString);
12615 return;
12616 } catch (Throwable e) {
12617 if (e.getClass() != java.lang.NullPointerException.class) {
12618 fail(runString, e);
12619 return;
12620 }
12621 }
12622 // (-1,false) == !java.lang.ArrayIndexOutOfBoundsException
12623 try {
12624 runString = "(-1,false)";
12625 jtt.except.BC_bastore.test(-1, false);
12626 fail(runString);
12627 return;
12628 } catch (Throwable e) {
12629 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12630 fail(runString, e);
12631 return;
12632 }
12633 }
12634 // (0,true) == true
12635 runString = "(0,true)";
12636 if (true != jtt.except.BC_bastore.test(0, true)) {
12637 fail(runString);
12638 return;
12639 }
12640 // (4,true) == !java.lang.ArrayIndexOutOfBoundsException
12641 try {
12642 runString = "(4,true)";
12643 jtt.except.BC_bastore.test(4, true);
12644 fail(runString);
12645 return;
12646 } catch (Throwable e) {
12647 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12648 fail(runString, e);
12649 return;
12650 }
12651 }
12652 } catch (Throwable t) {
12653 fail(runString, t);
12654 return;
12655 }
12656 pass();
12657 }
12658
12659 static void jtt_except_BC_caload() {
12660 begin("jtt.except.BC_caload");
12661 String runString = null;
12662 try {
12663 // (-2) == !java.lang.NullPointerException
12664 try {
12665 runString = "(-2)";
12666 jtt.except.BC_caload.test(-2);
12667 fail(runString);
12668 return;
12669 } catch (Throwable e) {
12670 if (e.getClass() != java.lang.NullPointerException.class) {
12671 fail(runString, e);
12672 return;
12673 }
12674 }
12675 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
12676 try {
12677 runString = "(-1)";
12678 jtt.except.BC_caload.test(-1);
12679 fail(runString);
12680 return;
12681 } catch (Throwable e) {
12682 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12683 fail(runString, e);
12684 return;
12685 }
12686 }
12687 // (0) == '\0'
12688 runString = "(0)";
12689 if ((char) 0 != jtt.except.BC_caload.test(0)) {
12690 fail(runString);
12691 return;
12692 }
12693 // (4) == !java.lang.ArrayIndexOutOfBoundsException
12694 try {
12695 runString = "(4)";
12696 jtt.except.BC_caload.test(4);
12697 fail(runString);
12698 return;
12699 } catch (Throwable e) {
12700 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12701 fail(runString, e);
12702 return;
12703 }
12704 }
12705 } catch (Throwable t) {
12706 fail(runString, t);
12707 return;
12708 }
12709 pass();
12710 }
12711
12712 static void jtt_except_BC_castore() {
12713 begin("jtt.except.BC_castore");
12714 String runString = null;
12715 try {
12716 // (-2,'a') == !java.lang.NullPointerException
12717 try {
12718 runString = "(-2,'a')";
12719 jtt.except.BC_castore.test(-2, (char) 97);
12720 fail(runString);
12721 return;
12722 } catch (Throwable e) {
12723 if (e.getClass() != java.lang.NullPointerException.class) {
12724 fail(runString, e);
12725 return;
12726 }
12727 }
12728 // (-1,'c') == !java.lang.ArrayIndexOutOfBoundsException
12729 try {
12730 runString = "(-1,'c')";
12731 jtt.except.BC_castore.test(-1, (char) 99);
12732 fail(runString);
12733 return;
12734 } catch (Throwable e) {
12735 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12736 fail(runString, e);
12737 return;
12738 }
12739 }
12740 // (0,'a') == 'a'
12741 runString = "(0,'a')";
12742 if ((char) 97 != jtt.except.BC_castore.test(0, (char) 97)) {
12743 fail(runString);
12744 return;
12745 }
12746 // (4,'a') == !java.lang.ArrayIndexOutOfBoundsException
12747 try {
12748 runString = "(4,'a')";
12749 jtt.except.BC_castore.test(4, (char) 97);
12750 fail(runString);
12751 return;
12752 } catch (Throwable e) {
12753 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
12754 fail(runString, e);
12755 return;
12756 }
12757 }
12758 } catch (Throwable t) {
12759 fail(runString, t);
12760 return;
12761 }
12762 pass();
12763 }
12764
12765 static void jtt_except_BC_checkcast() {
12766 begin("jtt.except.BC_checkcast");
12767 String runString = null;
12768 try {
12769 // (0) == 0
12770 runString = "(0)";
12771 if (0 != jtt.except.BC_checkcast.test(0)) {
12772 fail(runString);
12773 return;
12774 }
12775 // (2) == !java.lang.ClassCastException
12776 try {
12777 runString = "(2)";
12778 jtt.except.BC_checkcast.test(2);
12779 fail(runString);
12780 return;
12781 } catch (Throwable e) {
12782 if (e.getClass() != java.lang.ClassCastException.class) {
12783 fail(runString, e);
12784 return;
12785 }
12786 }
12787 // (3) == !java.lang.ClassCastException
12788 try {
12789 runString = "(3)";
12790 jtt.except.BC_checkcast.test(3);
12791 fail(runString);
12792 return;
12793 } catch (Throwable e) {
12794 if (e.getClass() != java.lang.ClassCastException.class) {
12795 fail(runString, e);
12796 return;
12797 }
12798 }
12799 // (4) == 4
12800 runString = "(4)";
12801 if (4 != jtt.except.BC_checkcast.test(4)) {
12802 fail(runString);
12803 return;
12804 }
12805 } catch (Throwable t) {
12806 fail(runString, t);
12807 return;
12808 }
12809 pass();
12810 }
12811
12812 static void jtt_except_BC_checkcast1() {
12813 begin("jtt.except.BC_checkcast1");
12814 String runString = null;
12815 try {
12816 // (0) == 0
12817 runString = "(0)";
12818 if (0 != jtt.except.BC_checkcast1.test(0)) {
12819 fail(runString);
12820 return;
12821 }
12822 // (2) == !java.lang.ClassCastException
12823 try {
12824 runString = "(2)";
12825 jtt.except.BC_checkcast1.test(2);
12826 fail(runString);
12827 return;
12828 } catch (Throwable e) {
12829 if (e.getClass() != java.lang.ClassCastException.class) {
12830 fail(runString, e);
12831 return;
12832 }
12833 }
12834 // (3) == !java.lang.ClassCastException
12835 try {
12836 runString = "(3)";
12837 jtt.except.BC_checkcast1.test(3);
12838 fail(runString);
12839 return;
12840 } catch (Throwable e) {
12841 if (e.getClass() != java.lang.ClassCastException.class) {
12842 fail(runString, e);
12843 return;
12844 }
12845 }
12846 // (4) == 4
12847 runString = "(4)";
12848 if (4 != jtt.except.BC_checkcast1.test(4)) {
12849 fail(runString);
12850 return;
12851 }
12852 } catch (Throwable t) {
12853 fail(runString, t);
12854 return;
12855 }
12856 pass();
12857 }
12858
12859 static void jtt_except_BC_checkcast2() {
12860 begin("jtt.except.BC_checkcast2");
12861 String runString = null;
12862 try {
12863 // (0) == -1
12864 runString = "(0)";
12865 if (-1 != jtt.except.BC_checkcast2.test(0)) {
12866 fail(runString);
12867 return;
12868 }
12869 // (1) == -1
12870 runString = "(1)";
12871 if (-1 != jtt.except.BC_checkcast2.test(1)) {
12872 fail(runString);
12873 return;
12874 }
12875 // (2) == !java.lang.ClassCastException
12876 try {
12877 runString = "(2)";
12878 jtt.except.BC_checkcast2.test(2);
12879 fail(runString);
12880 return;
12881 } catch (Throwable e) {
12882 if (e.getClass() != java.lang.ClassCastException.class) {
12883 fail(runString, e);
12884 return;
12885 }
12886 }
12887 // (3) == !java.lang.ClassCastException
12888 try {
12889 runString = "(3)";
12890 jtt.except.BC_checkcast2.test(3);
12891 fail(runString);
12892 return;
12893 } catch (Throwable e) {
12894 if (e.getClass() != java.lang.ClassCastException.class) {
12895 fail(runString, e);
12896 return;
12897 }
12898 }
12899 // (4) == 4
12900 runString = "(4)";
12901 if (4 != jtt.except.BC_checkcast2.test(4)) {
12902 fail(runString);
12903 return;
12904 }
12905 } catch (Throwable t) {
12906 fail(runString, t);
12907 return;
12908 }
12909 pass();
12910 }
12911
12912 static void jtt_except_BC_checkcast3() {
12913 begin("jtt.except.BC_checkcast3");
12914 String runString = null;
12915 try {
12916 // (0) == !java.lang.ClassCastException
12917 try {
12918 runString = "(0)";
12919 jtt.except.BC_checkcast3.test(0);
12920 fail(runString);
12921 return;
12922 } catch (Throwable e) {
12923 if (e.getClass() != java.lang.ClassCastException.class) {
12924 fail(runString, e);
12925 return;
12926 }
12927 }
12928 // (1) == !java.lang.ClassCastException
12929 try {
12930 runString = "(1)";
12931 jtt.except.BC_checkcast3.test(1);
12932 fail(runString);
12933 return;
12934 } catch (Throwable e) {
12935 if (e.getClass() != java.lang.ClassCastException.class) {
12936 fail(runString, e);
12937 return;
12938 }
12939 }
12940 // (2) == -1
12941 runString = "(2)";
12942 if (-1 != jtt.except.BC_checkcast3.test(2)) {
12943 fail(runString);
12944 return;
12945 }
12946 // (3) == -1
12947 runString = "(3)";
12948 if (-1 != jtt.except.BC_checkcast3.test(3)) {
12949 fail(runString);
12950 return;
12951 }
12952 } catch (Throwable t) {
12953 fail(runString, t);
12954 return;
12955 }
12956 pass();
12957 }
12958
12959 static void jtt_except_BC_checkcast4() {
12960 begin("jtt.except.BC_checkcast4");
12961 String runString = null;
12962 try {
12963 // (0) == -1
12964 runString = "(0)";
12965 if (-1 != jtt.except.BC_checkcast4.test(0)) {
12966 fail(runString);
12967 return;
12968 }
12969 // (1) == -1
12970 runString = "(1)";
12971 if (-1 != jtt.except.BC_checkcast4.test(1)) {
12972 fail(runString);
12973 return;
12974 }
12975 // (2) == !java.lang.ClassCastException
12976 try {
12977 runString = "(2)";
12978 jtt.except.BC_checkcast4.test(2);
12979 fail(runString);
12980 return;
12981 } catch (Throwable e) {
12982 if (e.getClass() != java.lang.ClassCastException.class) {
12983 fail(runString, e);
12984 return;
12985 }
12986 }
12987 // (3) == !java.lang.ClassCastException
12988 try {
12989 runString = "(3)";
12990 jtt.except.BC_checkcast4.test(3);
12991 fail(runString);
12992 return;
12993 } catch (Throwable e) {
12994 if (e.getClass() != java.lang.ClassCastException.class) {
12995 fail(runString, e);
12996 return;
12997 }
12998 }
12999 // (4) == 4
13000 runString = "(4)";
13001 if (4 != jtt.except.BC_checkcast4.test(4)) {
13002 fail(runString);
13003 return;
13004 }
13005 } catch (Throwable t) {
13006 fail(runString, t);
13007 return;
13008 }
13009 pass();
13010 }
13011
13012 static void jtt_except_BC_checkcast5() {
13013 begin("jtt.except.BC_checkcast5");
13014 String runString = null;
13015 try {
13016 // (0) == -1
13017 runString = "(0)";
13018 if (-1 != jtt.except.BC_checkcast5.test(0)) {
13019 fail(runString);
13020 return;
13021 }
13022 // (1) == -1
13023 runString = "(1)";
13024 if (-1 != jtt.except.BC_checkcast5.test(1)) {
13025 fail(runString);
13026 return;
13027 }
13028 // (2) == -5
13029 runString = "(2)";
13030 if (-5 != jtt.except.BC_checkcast5.test(2)) {
13031 fail(runString);
13032 return;
13033 }
13034 // (3) == -5
13035 runString = "(3)";
13036 if (-5 != jtt.except.BC_checkcast5.test(3)) {
13037 fail(runString);
13038 return;
13039 }
13040 // (4) == 4
13041 runString = "(4)";
13042 if (4 != jtt.except.BC_checkcast5.test(4)) {
13043 fail(runString);
13044 return;
13045 }
13046 } catch (Throwable t) {
13047 fail(runString, t);
13048 return;
13049 }
13050 pass();
13051 }
13052
13053 static void jtt_except_BC_checkcast6() {
13054 begin("jtt.except.BC_checkcast6");
13055 String runString = null;
13056 try {
13057 // (0) == -1
13058 runString = "(0)";
13059 if (-1 != jtt.except.BC_checkcast6.test(0)) {
13060 fail(runString);
13061 return;
13062 }
13063 // (1) == -1
13064 runString = "(1)";
13065 if (-1 != jtt.except.BC_checkcast6.test(1)) {
13066 fail(runString);
13067 return;
13068 }
13069 // (2) == -5
13070 runString = "(2)";
13071 if (-5 != jtt.except.BC_checkcast6.test(2)) {
13072 fail(runString);
13073 return;
13074 }
13075 // (3) == -5
13076 runString = "(3)";
13077 if (-5 != jtt.except.BC_checkcast6.test(3)) {
13078 fail(runString);
13079 return;
13080 }
13081 // (4) == 4
13082 runString = "(4)";
13083 if (4 != jtt.except.BC_checkcast6.test(4)) {
13084 fail(runString);
13085 return;
13086 }
13087 } catch (Throwable t) {
13088 fail(runString, t);
13089 return;
13090 }
13091 pass();
13092 }
13093
13094 static void jtt_except_BC_daload() {
13095 begin("jtt.except.BC_daload");
13096 String runString = null;
13097 try {
13098 // (-2) == !java.lang.NullPointerException
13099 try {
13100 runString = "(-2)";
13101 jtt.except.BC_daload.test(-2);
13102 fail(runString);
13103 return;
13104 } catch (Throwable e) {
13105 if (e.getClass() != java.lang.NullPointerException.class) {
13106 fail(runString, e);
13107 return;
13108 }
13109 }
13110 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
13111 try {
13112 runString = "(-1)";
13113 jtt.except.BC_daload.test(-1);
13114 fail(runString);
13115 return;
13116 } catch (Throwable e) {
13117 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13118 fail(runString, e);
13119 return;
13120 }
13121 }
13122 // (0) == 0.0
13123 runString = "(0)";
13124 if (0.0 != jtt.except.BC_daload.test(0)) {
13125 fail(runString);
13126 return;
13127 }
13128 // (4) == !java.lang.ArrayIndexOutOfBoundsException
13129 try {
13130 runString = "(4)";
13131 jtt.except.BC_daload.test(4);
13132 fail(runString);
13133 return;
13134 } catch (Throwable e) {
13135 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13136 fail(runString, e);
13137 return;
13138 }
13139 }
13140 } catch (Throwable t) {
13141 fail(runString, t);
13142 return;
13143 }
13144 pass();
13145 }
13146
13147 static void jtt_except_BC_dastore() {
13148 begin("jtt.except.BC_dastore");
13149 String runString = null;
13150 try {
13151 // (-2,0.01) == !java.lang.NullPointerException
13152 try {
13153 runString = "(-2,0.01)";
13154 jtt.except.BC_dastore.test(-2, 0.01);
13155 fail(runString);
13156 return;
13157 } catch (Throwable e) {
13158 if (e.getClass() != java.lang.NullPointerException.class) {
13159 fail(runString, e);
13160 return;
13161 }
13162 }
13163 // (-1,-1.4) == !java.lang.ArrayIndexOutOfBoundsException
13164 try {
13165 runString = "(-1,-1.4)";
13166 jtt.except.BC_dastore.test(-1, -1.4);
13167 fail(runString);
13168 return;
13169 } catch (Throwable e) {
13170 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13171 fail(runString, e);
13172 return;
13173 }
13174 }
13175 // (0,0.01) == 0.01
13176 runString = "(0,0.01)";
13177 if (0.01 != jtt.except.BC_dastore.test(0, 0.01)) {
13178 fail(runString);
13179 return;
13180 }
13181 // (4,0.01) == !java.lang.ArrayIndexOutOfBoundsException
13182 try {
13183 runString = "(4,0.01)";
13184 jtt.except.BC_dastore.test(4, 0.01);
13185 fail(runString);
13186 return;
13187 } catch (Throwable e) {
13188 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13189 fail(runString, e);
13190 return;
13191 }
13192 }
13193 } catch (Throwable t) {
13194 fail(runString, t);
13195 return;
13196 }
13197 pass();
13198 }
13199
13200 static void jtt_except_BC_faload() {
13201 begin("jtt.except.BC_faload");
13202 String runString = null;
13203 try {
13204 // (-2) == !java.lang.NullPointerException
13205 try {
13206 runString = "(-2)";
13207 jtt.except.BC_faload.test(-2);
13208 fail(runString);
13209 return;
13210 } catch (Throwable e) {
13211 if (e.getClass() != java.lang.NullPointerException.class) {
13212 fail(runString, e);
13213 return;
13214 }
13215 }
13216 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
13217 try {
13218 runString = "(-1)";
13219 jtt.except.BC_faload.test(-1);
13220 fail(runString);
13221 return;
13222 } catch (Throwable e) {
13223 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13224 fail(runString, e);
13225 return;
13226 }
13227 }
13228 // (0) == 0.0
13229 runString = "(0)";
13230 if (0.0f != jtt.except.BC_faload.test(0)) {
13231 fail(runString);
13232 return;
13233 }
13234 // (4) == !java.lang.ArrayIndexOutOfBoundsException
13235 try {
13236 runString = "(4)";
13237 jtt.except.BC_faload.test(4);
13238 fail(runString);
13239 return;
13240 } catch (Throwable e) {
13241 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13242 fail(runString, e);
13243 return;
13244 }
13245 }
13246 } catch (Throwable t) {
13247 fail(runString, t);
13248 return;
13249 }
13250 pass();
13251 }
13252
13253 static void jtt_except_BC_fastore() {
13254 begin("jtt.except.BC_fastore");
13255 String runString = null;
13256 try {
13257 // (-2,0.01) == !java.lang.NullPointerException
13258 try {
13259 runString = "(-2,0.01)";
13260 jtt.except.BC_fastore.test(-2, 0.01f);
13261 fail(runString);
13262 return;
13263 } catch (Throwable e) {
13264 if (e.getClass() != java.lang.NullPointerException.class) {
13265 fail(runString, e);
13266 return;
13267 }
13268 }
13269 // (-1,-1.4) == !java.lang.ArrayIndexOutOfBoundsException
13270 try {
13271 runString = "(-1,-1.4)";
13272 jtt.except.BC_fastore.test(-1, -1.4f);
13273 fail(runString);
13274 return;
13275 } catch (Throwable e) {
13276 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13277 fail(runString, e);
13278 return;
13279 }
13280 }
13281 // (0,0.01) == 0.01
13282 runString = "(0,0.01)";
13283 if (0.01f != jtt.except.BC_fastore.test(0, 0.01f)) {
13284 fail(runString);
13285 return;
13286 }
13287 // (4,0.01) == !java.lang.ArrayIndexOutOfBoundsException
13288 try {
13289 runString = "(4,0.01)";
13290 jtt.except.BC_fastore.test(4, 0.01f);
13291 fail(runString);
13292 return;
13293 } catch (Throwable e) {
13294 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13295 fail(runString, e);
13296 return;
13297 }
13298 }
13299 } catch (Throwable t) {
13300 fail(runString, t);
13301 return;
13302 }
13303 pass();
13304 }
13305
13306 static void jtt_except_BC_getfield() {
13307 begin("jtt.except.BC_getfield");
13308 String runString = null;
13309 try {
13310 // (0) == 13
13311 runString = "(0)";
13312 if (13 != jtt.except.BC_getfield.test(0)) {
13313 fail(runString);
13314 return;
13315 }
13316 // (3) == !java.lang.NullPointerException
13317 try {
13318 runString = "(3)";
13319 jtt.except.BC_getfield.test(3);
13320 fail(runString);
13321 return;
13322 } catch (Throwable e) {
13323 if (e.getClass() != java.lang.NullPointerException.class) {
13324 fail(runString, e);
13325 return;
13326 }
13327 }
13328 } catch (Throwable t) {
13329 fail(runString, t);
13330 return;
13331 }
13332 pass();
13333 }
13334
13335 static void jtt_except_BC_iaload() {
13336 begin("jtt.except.BC_iaload");
13337 String runString = null;
13338 try {
13339 // (-2) == !java.lang.NullPointerException
13340 try {
13341 runString = "(-2)";
13342 jtt.except.BC_iaload.test(-2);
13343 fail(runString);
13344 return;
13345 } catch (Throwable e) {
13346 if (e.getClass() != java.lang.NullPointerException.class) {
13347 fail(runString, e);
13348 return;
13349 }
13350 }
13351 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
13352 try {
13353 runString = "(-1)";
13354 jtt.except.BC_iaload.test(-1);
13355 fail(runString);
13356 return;
13357 } catch (Throwable e) {
13358 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13359 fail(runString, e);
13360 return;
13361 }
13362 }
13363 // (0) == 0
13364 runString = "(0)";
13365 if (0 != jtt.except.BC_iaload.test(0)) {
13366 fail(runString);
13367 return;
13368 }
13369 // (4) == !java.lang.ArrayIndexOutOfBoundsException
13370 try {
13371 runString = "(4)";
13372 jtt.except.BC_iaload.test(4);
13373 fail(runString);
13374 return;
13375 } catch (Throwable e) {
13376 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13377 fail(runString, e);
13378 return;
13379 }
13380 }
13381 } catch (Throwable t) {
13382 fail(runString, t);
13383 return;
13384 }
13385 pass();
13386 }
13387
13388 static void jtt_except_BC_iastore() {
13389 begin("jtt.except.BC_iastore");
13390 String runString = null;
13391 try {
13392 // (-2,0) == !java.lang.NullPointerException
13393 try {
13394 runString = "(-2,0)";
13395 jtt.except.BC_iastore.test(-2, 0);
13396 fail(runString);
13397 return;
13398 } catch (Throwable e) {
13399 if (e.getClass() != java.lang.NullPointerException.class) {
13400 fail(runString, e);
13401 return;
13402 }
13403 }
13404 // (-1,3) == !java.lang.ArrayIndexOutOfBoundsException
13405 try {
13406 runString = "(-1,3)";
13407 jtt.except.BC_iastore.test(-1, 3);
13408 fail(runString);
13409 return;
13410 } catch (Throwable e) {
13411 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13412 fail(runString, e);
13413 return;
13414 }
13415 }
13416 // (0,0) == 0
13417 runString = "(0,0)";
13418 if (0 != jtt.except.BC_iastore.test(0, 0)) {
13419 fail(runString);
13420 return;
13421 }
13422 // (4,0) == !java.lang.ArrayIndexOutOfBoundsException
13423 try {
13424 runString = "(4,0)";
13425 jtt.except.BC_iastore.test(4, 0);
13426 fail(runString);
13427 return;
13428 } catch (Throwable e) {
13429 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13430 fail(runString, e);
13431 return;
13432 }
13433 }
13434 } catch (Throwable t) {
13435 fail(runString, t);
13436 return;
13437 }
13438 pass();
13439 }
13440
13441 static void jtt_except_BC_idiv() {
13442 begin("jtt.except.BC_idiv");
13443 String runString = null;
13444 try {
13445 // (1,2) == 0
13446 runString = "(1,2)";
13447 if (0 != jtt.except.BC_idiv.test(1, 2)) {
13448 fail(runString);
13449 return;
13450 }
13451 // (11,0) == !java.lang.ArithmeticException
13452 try {
13453 runString = "(11,0)";
13454 jtt.except.BC_idiv.test(11, 0);
13455 fail(runString);
13456 return;
13457 } catch (Throwable e) {
13458 if (e.getClass() != java.lang.ArithmeticException.class) {
13459 fail(runString, e);
13460 return;
13461 }
13462 }
13463 } catch (Throwable t) {
13464 fail(runString, t);
13465 return;
13466 }
13467 pass();
13468 }
13469
13470 static void jtt_except_BC_idiv2() {
13471 begin("jtt.except.BC_idiv2");
13472 String runString = null;
13473 try {
13474 // (1,2) == 0
13475 runString = "(1,2)";
13476 if (0 != jtt.except.BC_idiv2.test(1, 2)) {
13477 fail(runString);
13478 return;
13479 }
13480 // (11,0) == -11
13481 runString = "(11,0)";
13482 if (-11 != jtt.except.BC_idiv2.test(11, 0)) {
13483 fail(runString);
13484 return;
13485 }
13486 } catch (Throwable t) {
13487 fail(runString, t);
13488 return;
13489 }
13490 pass();
13491 }
13492
13493 static void jtt_except_BC_invokespecial01() {
13494 begin("jtt.except.BC_invokespecial01");
13495 String runString = null;
13496 try {
13497 // (0) == true
13498 runString = "(0)";
13499 if (true != jtt.except.BC_invokespecial01.test(0)) {
13500 fail(runString);
13501 return;
13502 }
13503 // (1) == !java.lang.NullPointerException
13504 try {
13505 runString = "(1)";
13506 jtt.except.BC_invokespecial01.test(1);
13507 fail(runString);
13508 return;
13509 } catch (Throwable e) {
13510 if (e.getClass() != java.lang.NullPointerException.class) {
13511 fail(runString, e);
13512 return;
13513 }
13514 }
13515 } catch (Throwable t) {
13516 fail(runString, t);
13517 return;
13518 }
13519 pass();
13520 }
13521
13522 static void jtt_except_BC_invokevirtual01() {
13523 begin("jtt.except.BC_invokevirtual01");
13524 String runString = null;
13525 try {
13526 // (0) == true
13527 runString = "(0)";
13528 if (true != jtt.except.BC_invokevirtual01.test(0)) {
13529 fail(runString);
13530 return;
13531 }
13532 // (1) == !java.lang.NullPointerException
13533 try {
13534 runString = "(1)";
13535 jtt.except.BC_invokevirtual01.test(1);
13536 fail(runString);
13537 return;
13538 } catch (Throwable e) {
13539 if (e.getClass() != java.lang.NullPointerException.class) {
13540 fail(runString, e);
13541 return;
13542 }
13543 }
13544 } catch (Throwable t) {
13545 fail(runString, t);
13546 return;
13547 }
13548 pass();
13549 }
13550
13551 static void jtt_except_BC_invokevirtual02() {
13552 begin("jtt.except.BC_invokevirtual02");
13553 String runString = null;
13554 try {
13555 // (0) == true
13556 runString = "(0)";
13557 if (true != jtt.except.BC_invokevirtual02.test(0)) {
13558 fail(runString);
13559 return;
13560 }
13561 // (1) == !java.lang.NullPointerException
13562 try {
13563 runString = "(1)";
13564 jtt.except.BC_invokevirtual02.test(1);
13565 fail(runString);
13566 return;
13567 } catch (Throwable e) {
13568 if (e.getClass() != java.lang.NullPointerException.class) {
13569 fail(runString, e);
13570 return;
13571 }
13572 }
13573 } catch (Throwable t) {
13574 fail(runString, t);
13575 return;
13576 }
13577 pass();
13578 }
13579
13580 static void jtt_except_BC_irem() {
13581 begin("jtt.except.BC_irem");
13582 String runString = null;
13583 try {
13584 // (1,2) == 1
13585 runString = "(1,2)";
13586 if (1 != jtt.except.BC_irem.test(1, 2)) {
13587 fail(runString);
13588 return;
13589 }
13590 // (11,0) == !java.lang.ArithmeticException
13591 try {
13592 runString = "(11,0)";
13593 jtt.except.BC_irem.test(11, 0);
13594 fail(runString);
13595 return;
13596 } catch (Throwable e) {
13597 if (e.getClass() != java.lang.ArithmeticException.class) {
13598 fail(runString, e);
13599 return;
13600 }
13601 }
13602 } catch (Throwable t) {
13603 fail(runString, t);
13604 return;
13605 }
13606 pass();
13607 }
13608
13609 static void jtt_except_BC_laload() {
13610 begin("jtt.except.BC_laload");
13611 String runString = null;
13612 try {
13613 // (-2) == !java.lang.NullPointerException
13614 try {
13615 runString = "(-2)";
13616 jtt.except.BC_laload.test(-2);
13617 fail(runString);
13618 return;
13619 } catch (Throwable e) {
13620 if (e.getClass() != java.lang.NullPointerException.class) {
13621 fail(runString, e);
13622 return;
13623 }
13624 }
13625 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
13626 try {
13627 runString = "(-1)";
13628 jtt.except.BC_laload.test(-1);
13629 fail(runString);
13630 return;
13631 } catch (Throwable e) {
13632 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13633 fail(runString, e);
13634 return;
13635 }
13636 }
13637 // (0) == 0
13638 runString = "(0)";
13639 if (0L != jtt.except.BC_laload.test(0)) {
13640 fail(runString);
13641 return;
13642 }
13643 // (4) == !java.lang.ArrayIndexOutOfBoundsException
13644 try {
13645 runString = "(4)";
13646 jtt.except.BC_laload.test(4);
13647 fail(runString);
13648 return;
13649 } catch (Throwable e) {
13650 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13651 fail(runString, e);
13652 return;
13653 }
13654 }
13655 } catch (Throwable t) {
13656 fail(runString, t);
13657 return;
13658 }
13659 pass();
13660 }
13661
13662 static void jtt_except_BC_lastore() {
13663 begin("jtt.except.BC_lastore");
13664 String runString = null;
13665 try {
13666 // (-2,0) == !java.lang.NullPointerException
13667 try {
13668 runString = "(-2,0)";
13669 jtt.except.BC_lastore.test(-2, 0L);
13670 fail(runString);
13671 return;
13672 } catch (Throwable e) {
13673 if (e.getClass() != java.lang.NullPointerException.class) {
13674 fail(runString, e);
13675 return;
13676 }
13677 }
13678 // (-1,3) == !java.lang.ArrayIndexOutOfBoundsException
13679 try {
13680 runString = "(-1,3)";
13681 jtt.except.BC_lastore.test(-1, 3L);
13682 fail(runString);
13683 return;
13684 } catch (Throwable e) {
13685 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13686 fail(runString, e);
13687 return;
13688 }
13689 }
13690 // (0,0) == 0
13691 runString = "(0,0)";
13692 if (0L != jtt.except.BC_lastore.test(0, 0L)) {
13693 fail(runString);
13694 return;
13695 }
13696 // (4,0) == !java.lang.ArrayIndexOutOfBoundsException
13697 try {
13698 runString = "(4,0)";
13699 jtt.except.BC_lastore.test(4, 0L);
13700 fail(runString);
13701 return;
13702 } catch (Throwable e) {
13703 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13704 fail(runString, e);
13705 return;
13706 }
13707 }
13708 } catch (Throwable t) {
13709 fail(runString, t);
13710 return;
13711 }
13712 pass();
13713 }
13714
13715 static void jtt_except_BC_ldiv() {
13716 begin("jtt.except.BC_ldiv");
13717 String runString = null;
13718 try {
13719 // (1,2) == 0
13720 runString = "(1,2)";
13721 if (0L != jtt.except.BC_ldiv.test(1L, 2L)) {
13722 fail(runString);
13723 return;
13724 }
13725 // (11,0) == !java.lang.ArithmeticException
13726 try {
13727 runString = "(11,0)";
13728 jtt.except.BC_ldiv.test(11L, 0L);
13729 fail(runString);
13730 return;
13731 } catch (Throwable e) {
13732 if (e.getClass() != java.lang.ArithmeticException.class) {
13733 fail(runString, e);
13734 return;
13735 }
13736 }
13737 } catch (Throwable t) {
13738 fail(runString, t);
13739 return;
13740 }
13741 pass();
13742 }
13743
13744 static void jtt_except_BC_ldiv2() {
13745 begin("jtt.except.BC_ldiv2");
13746 String runString = null;
13747 try {
13748 // (1,2) == 0
13749 runString = "(1,2)";
13750 if (0L != jtt.except.BC_ldiv2.test(1L, 2L)) {
13751 fail(runString);
13752 return;
13753 }
13754 // (11,0) == -11
13755 runString = "(11,0)";
13756 if (-11L != jtt.except.BC_ldiv2.test(11L, 0L)) {
13757 fail(runString);
13758 return;
13759 }
13760 } catch (Throwable t) {
13761 fail(runString, t);
13762 return;
13763 }
13764 pass();
13765 }
13766
13767 static void jtt_except_BC_lrem() {
13768 begin("jtt.except.BC_lrem");
13769 String runString = null;
13770 try {
13771 // (1,2) == 1
13772 runString = "(1,2)";
13773 if (1L != jtt.except.BC_lrem.test(1L, 2L)) {
13774 fail(runString);
13775 return;
13776 }
13777 // (11,0) == !java.lang.ArithmeticException
13778 try {
13779 runString = "(11,0)";
13780 jtt.except.BC_lrem.test(11L, 0L);
13781 fail(runString);
13782 return;
13783 } catch (Throwable e) {
13784 if (e.getClass() != java.lang.ArithmeticException.class) {
13785 fail(runString, e);
13786 return;
13787 }
13788 }
13789 } catch (Throwable t) {
13790 fail(runString, t);
13791 return;
13792 }
13793 pass();
13794 }
13795
13796 static void jtt_except_BC_monitorenter() {
13797 begin("jtt.except.BC_monitorenter");
13798 String runString = null;
13799 try {
13800 // (true) == true
13801 runString = "(true)";
13802 if (true != jtt.except.BC_monitorenter.test(true)) {
13803 fail(runString);
13804 return;
13805 }
13806 // (false) == !java.lang.NullPointerException
13807 try {
13808 runString = "(false)";
13809 jtt.except.BC_monitorenter.test(false);
13810 fail(runString);
13811 return;
13812 } catch (Throwable e) {
13813 if (e.getClass() != java.lang.NullPointerException.class) {
13814 fail(runString, e);
13815 return;
13816 }
13817 }
13818 } catch (Throwable t) {
13819 fail(runString, t);
13820 return;
13821 }
13822 pass();
13823 }
13824
13825 static void jtt_except_BC_multianewarray() {
13826 begin("jtt.except.BC_multianewarray");
13827 String runString = null;
13828 try {
13829 // (0,0) == 0
13830 runString = "(0,0)";
13831 if (0 != jtt.except.BC_multianewarray.test(0, 0)) {
13832 fail(runString);
13833 return;
13834 }
13835 // (1,1) == 1
13836 runString = "(1,1)";
13837 if (1 != jtt.except.BC_multianewarray.test(1, 1)) {
13838 fail(runString);
13839 return;
13840 }
13841 // (-1,0) == !java.lang.NegativeArraySizeException
13842 try {
13843 runString = "(-1,0)";
13844 jtt.except.BC_multianewarray.test(-1, 0);
13845 fail(runString);
13846 return;
13847 } catch (Throwable e) {
13848 if (e.getClass() != java.lang.NegativeArraySizeException.class) {
13849 fail(runString, e);
13850 return;
13851 }
13852 }
13853 // (0,-1) == !java.lang.NegativeArraySizeException
13854 try {
13855 runString = "(0,-1)";
13856 jtt.except.BC_multianewarray.test(0, -1);
13857 fail(runString);
13858 return;
13859 } catch (Throwable e) {
13860 if (e.getClass() != java.lang.NegativeArraySizeException.class) {
13861 fail(runString, e);
13862 return;
13863 }
13864 }
13865 } catch (Throwable t) {
13866 fail(runString, t);
13867 return;
13868 }
13869 pass();
13870 }
13871
13872 static void jtt_except_BC_newarray() {
13873 begin("jtt.except.BC_newarray");
13874 String runString = null;
13875 try {
13876 // (-1) == !java.lang.NegativeArraySizeException
13877 try {
13878 runString = "(-1)";
13879 jtt.except.BC_newarray.test(-1);
13880 fail(runString);
13881 return;
13882 } catch (Throwable e) {
13883 if (e.getClass() != java.lang.NegativeArraySizeException.class) {
13884 fail(runString, e);
13885 return;
13886 }
13887 }
13888 // (0) == 0
13889 runString = "(0)";
13890 if (0 != jtt.except.BC_newarray.test(0)) {
13891 fail(runString);
13892 return;
13893 }
13894 // (1) == 1
13895 runString = "(1)";
13896 if (1 != jtt.except.BC_newarray.test(1)) {
13897 fail(runString);
13898 return;
13899 }
13900 } catch (Throwable t) {
13901 fail(runString, t);
13902 return;
13903 }
13904 pass();
13905 }
13906
13907 static void jtt_except_BC_putfield() {
13908 begin("jtt.except.BC_putfield");
13909 String runString = null;
13910 try {
13911 // (0) == 0
13912 runString = "(0)";
13913 if (0 != jtt.except.BC_putfield.test(0)) {
13914 fail(runString);
13915 return;
13916 }
13917 // (3) == !java.lang.NullPointerException
13918 try {
13919 runString = "(3)";
13920 jtt.except.BC_putfield.test(3);
13921 fail(runString);
13922 return;
13923 } catch (Throwable e) {
13924 if (e.getClass() != java.lang.NullPointerException.class) {
13925 fail(runString, e);
13926 return;
13927 }
13928 }
13929 // (-4) == -4
13930 runString = "(-4)";
13931 if (-4 != jtt.except.BC_putfield.test(-4)) {
13932 fail(runString);
13933 return;
13934 }
13935 } catch (Throwable t) {
13936 fail(runString, t);
13937 return;
13938 }
13939 pass();
13940 }
13941
13942 static void jtt_except_BC_saload() {
13943 begin("jtt.except.BC_saload");
13944 String runString = null;
13945 try {
13946 // (-2) == !java.lang.NullPointerException
13947 try {
13948 runString = "(-2)";
13949 jtt.except.BC_saload.test(-2);
13950 fail(runString);
13951 return;
13952 } catch (Throwable e) {
13953 if (e.getClass() != java.lang.NullPointerException.class) {
13954 fail(runString, e);
13955 return;
13956 }
13957 }
13958 // (-1) == !java.lang.ArrayIndexOutOfBoundsException
13959 try {
13960 runString = "(-1)";
13961 jtt.except.BC_saload.test(-1);
13962 fail(runString);
13963 return;
13964 } catch (Throwable e) {
13965 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13966 fail(runString, e);
13967 return;
13968 }
13969 }
13970 // (0) == 0
13971 runString = "(0)";
13972 if ((short) 0 != jtt.except.BC_saload.test(0)) {
13973 fail(runString);
13974 return;
13975 }
13976 // (4) == !java.lang.ArrayIndexOutOfBoundsException
13977 try {
13978 runString = "(4)";
13979 jtt.except.BC_saload.test(4);
13980 fail(runString);
13981 return;
13982 } catch (Throwable e) {
13983 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
13984 fail(runString, e);
13985 return;
13986 }
13987 }
13988 } catch (Throwable t) {
13989 fail(runString, t);
13990 return;
13991 }
13992 pass();
13993 }
13994
13995 static void jtt_except_BC_sastore() {
13996 begin("jtt.except.BC_sastore");
13997 String runString = null;
13998 try {
13999 // (-2,0) == !java.lang.NullPointerException
14000 try {
14001 runString = "(-2,0)";
14002 jtt.except.BC_sastore.test(-2, (short) 0);
14003 fail(runString);
14004 return;
14005 } catch (Throwable e) {
14006 if (e.getClass() != java.lang.NullPointerException.class) {
14007 fail(runString, e);
14008 return;
14009 }
14010 }
14011 // (-1,3) == !java.lang.ArrayIndexOutOfBoundsException
14012 try {
14013 runString = "(-1,3)";
14014 jtt.except.BC_sastore.test(-1, (short) 3);
14015 fail(runString);
14016 return;
14017 } catch (Throwable e) {
14018 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
14019 fail(runString, e);
14020 return;
14021 }
14022 }
14023 // (0,0) == 0
14024 runString = "(0,0)";
14025 if ((short) 0 != jtt.except.BC_sastore.test(0, (short) 0)) {
14026 fail(runString);
14027 return;
14028 }
14029 // (4,0) == !java.lang.ArrayIndexOutOfBoundsException
14030 try {
14031 runString = "(4,0)";
14032 jtt.except.BC_sastore.test(4, (short) 0);
14033 fail(runString);
14034 return;
14035 } catch (Throwable e) {
14036 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
14037 fail(runString, e);
14038 return;
14039 }
14040 }
14041 } catch (Throwable t) {
14042 fail(runString, t);
14043 return;
14044 }
14045 pass();
14046 }
14047
14048 static void jtt_except_Catch_Loop01() {
14049 begin("jtt.except.Catch_Loop01");
14050 String runString = null;
14051 try {
14052 // (4) == -170
14053 runString = "(4)";
14054 if (-170 != jtt.except.Catch_Loop01.test(4)) {
14055 fail(runString);
14056 return;
14057 }
14058 // (5) == -150
14059 runString = "(5)";
14060 if (-150 != jtt.except.Catch_Loop01.test(5)) {
14061 fail(runString);
14062 return;
14063 }
14064 // (6) == -140
14065 runString = "(6)";
14066 if (-140 != jtt.except.Catch_Loop01.test(6)) {
14067 fail(runString);
14068 return;
14069 }
14070 // (7) == -240
14071 runString = "(7)";
14072 if (-240 != jtt.except.Catch_Loop01.test(7)) {
14073 fail(runString);
14074 return;
14075 }
14076 // (30) == -700
14077 runString = "(30)";
14078 if (-700 != jtt.except.Catch_Loop01.test(30)) {
14079 fail(runString);
14080 return;
14081 }
14082 } catch (Throwable t) {
14083 fail(runString, t);
14084 return;
14085 }
14086 pass();
14087 }
14088
14089 static void jtt_except_Catch_Loop02() {
14090 begin("jtt.except.Catch_Loop02");
14091 String runString = null;
14092 try {
14093 // (4) == -170
14094 runString = "(4)";
14095 if (-170 != jtt.except.Catch_Loop02.test(4)) {
14096 fail(runString);
14097 return;
14098 }
14099 // (5) == -150
14100 runString = "(5)";
14101 if (-150 != jtt.except.Catch_Loop02.test(5)) {
14102 fail(runString);
14103 return;
14104 }
14105 // (6) == -140
14106 runString = "(6)";
14107 if (-140 != jtt.except.Catch_Loop02.test(6)) {
14108 fail(runString);
14109 return;
14110 }
14111 // (7) == -240
14112 runString = "(7)";
14113 if (-240 != jtt.except.Catch_Loop02.test(7)) {
14114 fail(runString);
14115 return;
14116 }
14117 // (30) == -700
14118 runString = "(30)";
14119 if (-700 != jtt.except.Catch_Loop02.test(30)) {
14120 fail(runString);
14121 return;
14122 }
14123 } catch (Throwable t) {
14124 fail(runString, t);
14125 return;
14126 }
14127 pass();
14128 }
14129
14130 static void jtt_except_Catch_NASE_1() {
14131 begin("jtt.except.Catch_NASE_1");
14132 String runString = null;
14133 try {
14134 // (-1) == 100
14135 runString = "(-1)";
14136 if (100 != jtt.except.Catch_NASE_1.test(-1)) {
14137 fail(runString);
14138 return;
14139 }
14140 // (-34) == 100
14141 runString = "(-34)";
14142 if (100 != jtt.except.Catch_NASE_1.test(-34)) {
14143 fail(runString);
14144 return;
14145 }
14146 } catch (Throwable t) {
14147 fail(runString, t);
14148 return;
14149 }
14150 pass();
14151 }
14152
14153 static void jtt_except_Catch_NASE_2() {
14154 begin("jtt.except.Catch_NASE_2");
14155 String runString = null;
14156 try {
14157 // (-1) == 100
14158 runString = "(-1)";
14159 if (100 != jtt.except.Catch_NASE_2.test(-1)) {
14160 fail(runString);
14161 return;
14162 }
14163 // (-34) == 100
14164 runString = "(-34)";
14165 if (100 != jtt.except.Catch_NASE_2.test(-34)) {
14166 fail(runString);
14167 return;
14168 }
14169 } catch (Throwable t) {
14170 fail(runString, t);
14171 return;
14172 }
14173 pass();
14174 }
14175
14176 static void jtt_except_Catch_NPE_00() {
14177 begin("jtt.except.Catch_NPE_00");
14178 String runString = null;
14179 try {
14180 // (-3) == -1
14181 runString = "(-3)";
14182 if (-1 != jtt.except.Catch_NPE_00.test(-3)) {
14183 fail(runString);
14184 return;
14185 }
14186 // (0) == -1
14187 runString = "(0)";
14188 if (-1 != jtt.except.Catch_NPE_00.test(0)) {
14189 fail(runString);
14190 return;
14191 }
14192 // (1) == 3
14193 runString = "(1)";
14194 if (3 != jtt.except.Catch_NPE_00.test(1)) {
14195 fail(runString);
14196 return;
14197 }
14198 // (2) == 3
14199 runString = "(2)";
14200 if (3 != jtt.except.Catch_NPE_00.test(2)) {
14201 fail(runString);
14202 return;
14203 }
14204 } catch (Throwable t) {
14205 fail(runString, t);
14206 return;
14207 }
14208 pass();
14209 }
14210
14211 static void jtt_except_Catch_NPE_01() {
14212 begin("jtt.except.Catch_NPE_01");
14213 String runString = null;
14214 try {
14215 // (0) == 0
14216 runString = "(0)";
14217 if (0 != jtt.except.Catch_NPE_01.test(0)) {
14218 fail(runString);
14219 return;
14220 }
14221 // (1) == 1
14222 runString = "(1)";
14223 if (1 != jtt.except.Catch_NPE_01.test(1)) {
14224 fail(runString);
14225 return;
14226 }
14227 // (-2) == -1
14228 runString = "(-2)";
14229 if (-1 != jtt.except.Catch_NPE_01.test(-2)) {
14230 fail(runString);
14231 return;
14232 }
14233 } catch (Throwable t) {
14234 fail(runString, t);
14235 return;
14236 }
14237 pass();
14238 }
14239
14240 static void jtt_except_Catch_NPE_02() {
14241 begin("jtt.except.Catch_NPE_02");
14242 String runString = null;
14243 try {
14244 // (0) == 0
14245 runString = "(0)";
14246 if (0 != jtt.except.Catch_NPE_02.test(0)) {
14247 fail(runString);
14248 return;
14249 }
14250 // (1) == 1
14251 runString = "(1)";
14252 if (1 != jtt.except.Catch_NPE_02.test(1)) {
14253 fail(runString);
14254 return;
14255 }
14256 // (-2) == -1
14257 runString = "(-2)";
14258 if (-1 != jtt.except.Catch_NPE_02.test(-2)) {
14259 fail(runString);
14260 return;
14261 }
14262 } catch (Throwable t) {
14263 fail(runString, t);
14264 return;
14265 }
14266 pass();
14267 }
14268
14269 static void jtt_except_Catch_NPE_03() {
14270 begin("jtt.except.Catch_NPE_03");
14271 String runString = null;
14272 try {
14273 // (0) == 0
14274 runString = "(0)";
14275 if (0 != jtt.except.Catch_NPE_03.test(0)) {
14276 fail(runString);
14277 return;
14278 }
14279 // (1) == 1
14280 runString = "(1)";
14281 if (1 != jtt.except.Catch_NPE_03.test(1)) {
14282 fail(runString);
14283 return;
14284 }
14285 // (-2) == -1
14286 runString = "(-2)";
14287 if (-1 != jtt.except.Catch_NPE_03.test(-2)) {
14288 fail(runString);
14289 return;
14290 }
14291 } catch (Throwable t) {
14292 fail(runString, t);
14293 return;
14294 }
14295 pass();
14296 }
14297
14298 static void jtt_except_Catch_NPE_04() {
14299 begin("jtt.except.Catch_NPE_04");
14300 String runString = null;
14301 try {
14302 // (0) == 0
14303 runString = "(0)";
14304 if (0 != jtt.except.Catch_NPE_04.test(0)) {
14305 fail(runString);
14306 return;
14307 }
14308 // (1) == 1
14309 runString = "(1)";
14310 if (1 != jtt.except.Catch_NPE_04.test(1)) {
14311 fail(runString);
14312 return;
14313 }
14314 // (-2) == -1
14315 runString = "(-2)";
14316 if (-1 != jtt.except.Catch_NPE_04.test(-2)) {
14317 fail(runString);
14318 return;
14319 }
14320 } catch (Throwable t) {
14321 fail(runString, t);
14322 return;
14323 }
14324 pass();
14325 }
14326
14327 static void jtt_except_Catch_NPE_05() {
14328 begin("jtt.except.Catch_NPE_05");
14329 String runString = null;
14330 try {
14331 // (0) == 0
14332 runString = "(0)";
14333 if (0 != jtt.except.Catch_NPE_05.test(0)) {
14334 fail(runString);
14335 return;
14336 }
14337 // (1) == 1
14338 runString = "(1)";
14339 if (1 != jtt.except.Catch_NPE_05.test(1)) {
14340 fail(runString);
14341 return;
14342 }
14343 // (-2) == -1
14344 runString = "(-2)";
14345 if (-1 != jtt.except.Catch_NPE_05.test(-2)) {
14346 fail(runString);
14347 return;
14348 }
14349 } catch (Throwable t) {
14350 fail(runString, t);
14351 return;
14352 }
14353 pass();
14354 }
14355
14356 static void jtt_except_Catch_NPE_06() {
14357 begin("jtt.except.Catch_NPE_06");
14358 String runString = null;
14359 try {
14360 // ("") == 0
14361 runString = "(\"\")";
14362 if (0 != jtt.except.Catch_NPE_06.test("")) {
14363 fail(runString);
14364 return;
14365 }
14366 // (null) == -1
14367 runString = "(null)";
14368 if (-1 != jtt.except.Catch_NPE_06.test(null)) {
14369 fail(runString);
14370 return;
14371 }
14372 } catch (Throwable t) {
14373 fail(runString, t);
14374 return;
14375 }
14376 pass();
14377 }
14378
14379 static void jtt_except_Catch_NPE_07() {
14380 begin("jtt.except.Catch_NPE_07");
14381 String runString = null;
14382 try {
14383 // (0) == 0
14384 runString = "(0)";
14385 if (0 != jtt.except.Catch_NPE_07.test(0)) {
14386 fail(runString);
14387 return;
14388 }
14389 // (1) == 1
14390 runString = "(1)";
14391 if (1 != jtt.except.Catch_NPE_07.test(1)) {
14392 fail(runString);
14393 return;
14394 }
14395 } catch (Throwable t) {
14396 fail(runString, t);
14397 return;
14398 }
14399 pass();
14400 }
14401
14402 static void jtt_except_Catch_NPE_08() {
14403 begin("jtt.except.Catch_NPE_08");
14404 String runString = null;
14405 try {
14406 // (0) == 0
14407 runString = "(0)";
14408 if (0 != jtt.except.Catch_NPE_08.test(0)) {
14409 fail(runString);
14410 return;
14411 }
14412 // (1) == 1
14413 runString = "(1)";
14414 if (1 != jtt.except.Catch_NPE_08.test(1)) {
14415 fail(runString);
14416 return;
14417 }
14418 // (-2) == -2
14419 runString = "(-2)";
14420 if (-2 != jtt.except.Catch_NPE_08.test(-2)) {
14421 fail(runString);
14422 return;
14423 }
14424 } catch (Throwable t) {
14425 fail(runString, t);
14426 return;
14427 }
14428 pass();
14429 }
14430
14431 static void jtt_except_Catch_NPE_09() {
14432 begin("jtt.except.Catch_NPE_09");
14433 String runString = null;
14434 try {
14435 // (0) == 10
14436 runString = "(0)";
14437 if (10 != jtt.except.Catch_NPE_09.test(0)) {
14438 fail(runString);
14439 return;
14440 }
14441 // (1) == 11
14442 runString = "(1)";
14443 if (11 != jtt.except.Catch_NPE_09.test(1)) {
14444 fail(runString);
14445 return;
14446 }
14447 // (2) == 1
14448 runString = "(2)";
14449 if (1 != jtt.except.Catch_NPE_09.test(2)) {
14450 fail(runString);
14451 return;
14452 }
14453 } catch (Throwable t) {
14454 fail(runString, t);
14455 return;
14456 }
14457 pass();
14458 }
14459
14460 static void jtt_except_Catch_NPE_10() {
14461 begin("jtt.except.Catch_NPE_10");
14462 String runString = null;
14463 try {
14464 // (0) == 10
14465 runString = "(0)";
14466 if (10 != jtt.except.Catch_NPE_10.test(0)) {
14467 fail(runString);
14468 return;
14469 }
14470 // (1) == 11
14471 runString = "(1)";
14472 if (11 != jtt.except.Catch_NPE_10.test(1)) {
14473 fail(runString);
14474 return;
14475 }
14476 // (2) == 1
14477 runString = "(2)";
14478 if (1 != jtt.except.Catch_NPE_10.test(2)) {
14479 fail(runString);
14480 return;
14481 }
14482 } catch (Throwable t) {
14483 fail(runString, t);
14484 return;
14485 }
14486 pass();
14487 }
14488
14489 static void jtt_except_Catch_NPE_11() {
14490 begin("jtt.except.Catch_NPE_11");
14491 String runString = null;
14492 try {
14493 // (0) == 10
14494 runString = "(0)";
14495 if (10 != jtt.except.Catch_NPE_11.test(0)) {
14496 fail(runString);
14497 return;
14498 }
14499 // (1) == 11
14500 runString = "(1)";
14501 if (11 != jtt.except.Catch_NPE_11.test(1)) {
14502 fail(runString);
14503 return;
14504 }
14505 // (2) == 1
14506 runString = "(2)";
14507 if (1 != jtt.except.Catch_NPE_11.test(2)) {
14508 fail(runString);
14509 return;
14510 }
14511 } catch (Throwable t) {
14512 fail(runString, t);
14513 return;
14514 }
14515 pass();
14516 }
14517
14518 static void jtt_except_Catch_StackOverflowError_01() {
14519 begin("jtt.except.Catch_StackOverflowError_01");
14520 String runString = null;
14521 try {
14522 // (0) == !java.lang.StackOverflowError
14523 try {
14524 runString = "(0)";
14525 jtt.except.Catch_StackOverflowError_01.test(0);
14526 fail(runString);
14527 return;
14528 } catch (Throwable e) {
14529 if (e.getClass() != java.lang.StackOverflowError.class) {
14530 fail(runString, e);
14531 return;
14532 }
14533 }
14534 } catch (Throwable t) {
14535 fail(runString, t);
14536 return;
14537 }
14538 pass();
14539 }
14540
14541 static void jtt_except_Catch_StackOverflowError_02() {
14542 begin("jtt.except.Catch_StackOverflowError_02");
14543 String runString = null;
14544 try {
14545 // (0) == !java.lang.StackOverflowError
14546 try {
14547 runString = "(0)";
14548 jtt.except.Catch_StackOverflowError_02.test(0);
14549 fail(runString);
14550 return;
14551 } catch (Throwable e) {
14552 if (e.getClass() != java.lang.StackOverflowError.class) {
14553 fail(runString, e);
14554 return;
14555 }
14556 }
14557 } catch (Throwable t) {
14558 fail(runString, t);
14559 return;
14560 }
14561 pass();
14562 }
14563
14564 static void jtt_except_Catch_StackOverflowError_03() {
14565 begin("jtt.except.Catch_StackOverflowError_03");
14566 String runString = null;
14567 try {
14568 // (0) == 0
14569 runString = "(0)";
14570 if (0 != jtt.except.Catch_StackOverflowError_03.test(0)) {
14571 fail(runString);
14572 return;
14573 }
14574 } catch (Throwable t) {
14575 fail(runString, t);
14576 return;
14577 }
14578 pass();
14579 }
14580
14581 static void jtt_except_Catch_Two01() {
14582 begin("jtt.except.Catch_Two01");
14583 String runString = null;
14584 try {
14585 // (0) == "java.lang.NullPointerException"
14586 runString = "(0)";
14587 if (!"java.lang.NullPointerException".equals(jtt.except.Catch_Two01
14588 .test(0))) {
14589 fail(runString);
14590 return;
14591 }
14592 // (1) == "java.lang.ArithmeticException"
14593 runString = "(1)";
14594 if (!"java.lang.ArithmeticException".equals(jtt.except.Catch_Two01
14595 .test(1))) {
14596 fail(runString);
14597 return;
14598 }
14599 // (3) == "none"
14600 runString = "(3)";
14601 if (!"none".equals(jtt.except.Catch_Two01.test(3))) {
14602 fail(runString);
14603 return;
14604 }
14605 } catch (Throwable t) {
14606 fail(runString, t);
14607 return;
14608 }
14609 pass();
14610 }
14611
14612 static void jtt_except_Catch_Two02() {
14613 begin("jtt.except.Catch_Two02");
14614 String runString = null;
14615 try {
14616 // (0) == "java.lang.NullPointerException"
14617 runString = "(0)";
14618 if (!"java.lang.NullPointerException".equals(jtt.except.Catch_Two02
14619 .test(0))) {
14620 fail(runString);
14621 return;
14622 }
14623 // (1) == "java.lang.ArithmeticException"
14624 runString = "(1)";
14625 if (!"java.lang.ArithmeticException".equals(jtt.except.Catch_Two02
14626 .test(1))) {
14627 fail(runString);
14628 return;
14629 }
14630 // (3) == "none13"
14631 runString = "(3)";
14632 if (!"none13".equals(jtt.except.Catch_Two02.test(3))) {
14633 fail(runString);
14634 return;
14635 }
14636 } catch (Throwable t) {
14637 fail(runString, t);
14638 return;
14639 }
14640 pass();
14641 }
14642
14643 static void jtt_except_Catch_Two03() {
14644 begin("jtt.except.Catch_Two03");
14645 String runString = null;
14646 try {
14647 // (0) == "none4"
14648 runString = "(0)";
14649 if (!"none4".equals(jtt.except.Catch_Two03.test(0))) {
14650 fail(runString);
14651 return;
14652 }
14653 // (1) == "none4"
14654 runString = "(1)";
14655 if (!"none4".equals(jtt.except.Catch_Two03.test(1))) {
14656 fail(runString);
14657 return;
14658 }
14659 // (2) == "java.lang.NullPointerException3"
14660 runString = "(2)";
14661 if (!"java.lang.NullPointerException3"
14662 .equals(jtt.except.Catch_Two03.test(2))) {
14663 fail(runString);
14664 return;
14665 }
14666 } catch (Throwable t) {
14667 fail(runString, t);
14668 return;
14669 }
14670 pass();
14671 }
14672
14673 static void jtt_except_Except_Synchronized01() {
14674 begin("jtt.except.Except_Synchronized01");
14675 String runString = null;
14676 try {
14677 // (0) == 0
14678 runString = "(0)";
14679 if (0 != jtt.except.Except_Synchronized01.test(0)) {
14680 fail(runString);
14681 return;
14682 }
14683 // (1) == 2
14684 runString = "(1)";
14685 if (2 != jtt.except.Except_Synchronized01.test(1)) {
14686 fail(runString);
14687 return;
14688 }
14689 } catch (Throwable t) {
14690 fail(runString, t);
14691 return;
14692 }
14693 pass();
14694 }
14695
14696 static void jtt_except_Except_Synchronized02() {
14697 begin("jtt.except.Except_Synchronized02");
14698 String runString = null;
14699 try {
14700 // (0) == 0
14701 runString = "(0)";
14702 if (0 != jtt.except.Except_Synchronized02.test(0)) {
14703 fail(runString);
14704 return;
14705 }
14706 // (1) == 2
14707 runString = "(1)";
14708 if (2 != jtt.except.Except_Synchronized02.test(1)) {
14709 fail(runString);
14710 return;
14711 }
14712 } catch (Throwable t) {
14713 fail(runString, t);
14714 return;
14715 }
14716 pass();
14717 }
14718
14719 static void jtt_except_Except_Synchronized03() {
14720 begin("jtt.except.Except_Synchronized03");
14721 String runString = null;
14722 try {
14723 // (0) == 0
14724 runString = "(0)";
14725 if (0 != jtt.except.Except_Synchronized03.test(0)) {
14726 fail(runString);
14727 return;
14728 }
14729 // (1) == 2
14730 runString = "(1)";
14731 if (2 != jtt.except.Except_Synchronized03.test(1)) {
14732 fail(runString);
14733 return;
14734 }
14735 } catch (Throwable t) {
14736 fail(runString, t);
14737 return;
14738 }
14739 pass();
14740 }
14741
14742 static void jtt_except_Except_Synchronized04() {
14743 begin("jtt.except.Except_Synchronized04");
14744 String runString = null;
14745 try {
14746 // (0) == 0
14747 runString = "(0)";
14748 if (0 != jtt.except.Except_Synchronized04.test(0)) {
14749 fail(runString);
14750 return;
14751 }
14752 // (1) == 2
14753 runString = "(1)";
14754 if (2 != jtt.except.Except_Synchronized04.test(1)) {
14755 fail(runString);
14756 return;
14757 }
14758 } catch (Throwable t) {
14759 fail(runString, t);
14760 return;
14761 }
14762 pass();
14763 }
14764
14765 static void jtt_except_Except_Synchronized05() {
14766 begin("jtt.except.Except_Synchronized05");
14767 String runString = null;
14768 try {
14769 // (0) == 0
14770 runString = "(0)";
14771 if (0 != jtt.except.Except_Synchronized05.test(0)) {
14772 fail(runString);
14773 return;
14774 }
14775 // (1) == 2
14776 runString = "(1)";
14777 if (2 != jtt.except.Except_Synchronized05.test(1)) {
14778 fail(runString);
14779 return;
14780 }
14781 } catch (Throwable t) {
14782 fail(runString, t);
14783 return;
14784 }
14785 pass();
14786 }
14787
14788 static void jtt_except_Finally01() {
14789 begin("jtt.except.Finally01");
14790 String runString = null;
14791 try {
14792 // (0) == -1
14793 runString = "(0)";
14794 if (-1 != jtt.except.Finally01.test(0)) {
14795 fail(runString);
14796 return;
14797 }
14798 // (1) == -1
14799 runString = "(1)";
14800 if (-1 != jtt.except.Finally01.test(1)) {
14801 fail(runString);
14802 return;
14803 }
14804 } catch (Throwable t) {
14805 fail(runString, t);
14806 return;
14807 }
14808 pass();
14809 }
14810
14811 static void jtt_except_Finally02() {
14812 begin("jtt.except.Finally02");
14813 String runString = null;
14814 try {
14815 // (0) == -1
14816 runString = "(0)";
14817 if (-1 != jtt.except.Finally02.test(0)) {
14818 fail(runString);
14819 return;
14820 }
14821 // (1) == -1
14822 runString = "(1)";
14823 if (-1 != jtt.except.Finally02.test(1)) {
14824 fail(runString);
14825 return;
14826 }
14827 } catch (Throwable t) {
14828 fail(runString, t);
14829 return;
14830 }
14831 pass();
14832 }
14833
14834 static void jtt_except_StackTrace_AIOOBE_00() {
14835 begin("jtt.except.StackTrace_AIOOBE_00");
14836 String runString = null;
14837 try {
14838 // (0) == 0
14839 runString = "(0)";
14840 if (0 != jtt.except.StackTrace_AIOOBE_00.test(0)) {
14841 fail(runString);
14842 return;
14843 }
14844 // (1) == 0
14845 runString = "(1)";
14846 if (0 != jtt.except.StackTrace_AIOOBE_00.test(1)) {
14847 fail(runString);
14848 return;
14849 }
14850 // (-2) == -1
14851 runString = "(-2)";
14852 if (-1 != jtt.except.StackTrace_AIOOBE_00.test(-2)) {
14853 fail(runString);
14854 return;
14855 }
14856 // (3) == -1
14857 runString = "(3)";
14858 if (-1 != jtt.except.StackTrace_AIOOBE_00.test(3)) {
14859 fail(runString);
14860 return;
14861 }
14862 } catch (Throwable t) {
14863 fail(runString, t);
14864 return;
14865 }
14866 pass();
14867 }
14868
14869 static void jtt_except_StackTrace_CCE_00() {
14870 begin("jtt.except.StackTrace_CCE_00");
14871 String runString = null;
14872 try {
14873 // (0) == 0
14874 runString = "(0)";
14875 if (0 != jtt.except.StackTrace_CCE_00.test(0)) {
14876 fail(runString);
14877 return;
14878 }
14879 // (2) == -100
14880 runString = "(2)";
14881 if (-100 != jtt.except.StackTrace_CCE_00.test(2)) {
14882 fail(runString);
14883 return;
14884 }
14885 // (3) == -100
14886 runString = "(3)";
14887 if (-100 != jtt.except.StackTrace_CCE_00.test(3)) {
14888 fail(runString);
14889 return;
14890 }
14891 // (4) == 4
14892 runString = "(4)";
14893 if (4 != jtt.except.StackTrace_CCE_00.test(4)) {
14894 fail(runString);
14895 return;
14896 }
14897 } catch (Throwable t) {
14898 fail(runString, t);
14899 return;
14900 }
14901 pass();
14902 }
14903
14904 static void jtt_except_StackTrace_NPE_00() {
14905 begin("jtt.except.StackTrace_NPE_00");
14906 String runString = null;
14907 try {
14908 // (-3) == -1
14909 runString = "(-3)";
14910 if (-1 != jtt.except.StackTrace_NPE_00.test(-3)) {
14911 fail(runString);
14912 return;
14913 }
14914 // (0) == -1
14915 runString = "(0)";
14916 if (-1 != jtt.except.StackTrace_NPE_00.test(0)) {
14917 fail(runString);
14918 return;
14919 }
14920 // (1) == 3
14921 runString = "(1)";
14922 if (3 != jtt.except.StackTrace_NPE_00.test(1)) {
14923 fail(runString);
14924 return;
14925 }
14926 // (2) == 3
14927 runString = "(2)";
14928 if (3 != jtt.except.StackTrace_NPE_00.test(2)) {
14929 fail(runString);
14930 return;
14931 }
14932 } catch (Throwable t) {
14933 fail(runString, t);
14934 return;
14935 }
14936 pass();
14937 }
14938
14939 static void jtt_except_StackTrace_NPE_01() {
14940 begin("jtt.except.StackTrace_NPE_01");
14941 String runString = null;
14942 try {
14943 // (0) == 0
14944 runString = "(0)";
14945 if (0 != jtt.except.StackTrace_NPE_01.test(0)) {
14946 fail(runString);
14947 return;
14948 }
14949 // (1) == 1
14950 runString = "(1)";
14951 if (1 != jtt.except.StackTrace_NPE_01.test(1)) {
14952 fail(runString);
14953 return;
14954 }
14955 // (-2) == -1
14956 runString = "(-2)";
14957 if (-1 != jtt.except.StackTrace_NPE_01.test(-2)) {
14958 fail(runString);
14959 return;
14960 }
14961 } catch (Throwable t) {
14962 fail(runString, t);
14963 return;
14964 }
14965 pass();
14966 }
14967
14968 static void jtt_except_StackTrace_NPE_02() {
14969 begin("jtt.except.StackTrace_NPE_02");
14970 String runString = null;
14971 try {
14972 // (0) == 0
14973 runString = "(0)";
14974 if (0 != jtt.except.StackTrace_NPE_02.test(0)) {
14975 fail(runString);
14976 return;
14977 }
14978 // (1) == 0
14979 runString = "(1)";
14980 if (0 != jtt.except.StackTrace_NPE_02.test(1)) {
14981 fail(runString);
14982 return;
14983 }
14984 // (-2) == -1
14985 runString = "(-2)";
14986 if (-1 != jtt.except.StackTrace_NPE_02.test(-2)) {
14987 fail(runString);
14988 return;
14989 }
14990 // (3) == 0
14991 runString = "(3)";
14992 if (0 != jtt.except.StackTrace_NPE_02.test(3)) {
14993 fail(runString);
14994 return;
14995 }
14996 } catch (Throwable t) {
14997 fail(runString, t);
14998 return;
14999 }
15000 pass();
15001 }
15002
15003 static void jtt_except_StackTrace_NPE_03() {
15004 begin("jtt.except.StackTrace_NPE_03");
15005 String runString = null;
15006 try {
15007 // (0) == 0
15008 runString = "(0)";
15009 if (0 != jtt.except.StackTrace_NPE_03.test(0)) {
15010 fail(runString);
15011 return;
15012 }
15013 // (1) == 0
15014 runString = "(1)";
15015 if (0 != jtt.except.StackTrace_NPE_03.test(1)) {
15016 fail(runString);
15017 return;
15018 }
15019 // (-2) == -1
15020 runString = "(-2)";
15021 if (-1 != jtt.except.StackTrace_NPE_03.test(-2)) {
15022 fail(runString);
15023 return;
15024 }
15025 // (3) == 0
15026 runString = "(3)";
15027 if (0 != jtt.except.StackTrace_NPE_03.test(3)) {
15028 fail(runString);
15029 return;
15030 }
15031 } catch (Throwable t) {
15032 fail(runString, t);
15033 return;
15034 }
15035 pass();
15036 }
15037
15038 static void jtt_except_Throw_InCatch01() {
15039 begin("jtt.except.Throw_InCatch01");
15040 String runString = null;
15041 try {
15042 // (0) == true
15043 runString = "(0)";
15044 if (true != jtt.except.Throw_InCatch01.test(0)) {
15045 fail(runString);
15046 return;
15047 }
15048 // (1) == !java.lang.Exception
15049 try {
15050 runString = "(1)";
15051 jtt.except.Throw_InCatch01.test(1);
15052 fail(runString);
15053 return;
15054 } catch (Throwable e) {
15055 if (e.getClass() != java.lang.Exception.class) {
15056 fail(runString, e);
15057 return;
15058 }
15059 }
15060 } catch (Throwable t) {
15061 fail(runString, t);
15062 return;
15063 }
15064 pass();
15065 }
15066
15067 static void jtt_except_Throw_InCatch02() {
15068 begin("jtt.except.Throw_InCatch02");
15069 String runString = null;
15070 try {
15071 // (0) == true
15072 runString = "(0)";
15073 if (true != jtt.except.Throw_InCatch02.test(0)) {
15074 fail(runString);
15075 return;
15076 }
15077 // (1) == !java.lang.Exception
15078 try {
15079 runString = "(1)";
15080 jtt.except.Throw_InCatch02.test(1);
15081 fail(runString);
15082 return;
15083 } catch (Throwable e) {
15084 if (e.getClass() != java.lang.Exception.class) {
15085 fail(runString, e);
15086 return;
15087 }
15088 }
15089 } catch (Throwable t) {
15090 fail(runString, t);
15091 return;
15092 }
15093 pass();
15094 }
15095
15096 static void jtt_except_Throw_InCatch03() {
15097 begin("jtt.except.Throw_InCatch03");
15098 String runString = null;
15099 try {
15100 // (0) == true
15101 runString = "(0)";
15102 if (true != jtt.except.Throw_InCatch03.test(0)) {
15103 fail(runString);
15104 return;
15105 }
15106 // (1) == !java.lang.Exception
15107 try {
15108 runString = "(1)";
15109 jtt.except.Throw_InCatch03.test(1);
15110 fail(runString);
15111 return;
15112 } catch (Throwable e) {
15113 if (e.getClass() != java.lang.Exception.class) {
15114 fail(runString, e);
15115 return;
15116 }
15117 }
15118 } catch (Throwable t) {
15119 fail(runString, t);
15120 return;
15121 }
15122 pass();
15123 }
15124
15125 static void jtt_except_Throw_NPE_01() {
15126 begin("jtt.except.Throw_NPE_01");
15127 String runString = null;
15128 try {
15129 // (0) == 1
15130 runString = "(0)";
15131 if (1 != jtt.except.Throw_NPE_01.test(0)) {
15132 fail(runString);
15133 return;
15134 }
15135 // (1) == 2
15136 runString = "(1)";
15137 if (2 != jtt.except.Throw_NPE_01.test(1)) {
15138 fail(runString);
15139 return;
15140 }
15141 // (-1) == !java.lang.NullPointerException
15142 try {
15143 runString = "(-1)";
15144 jtt.except.Throw_NPE_01.test(-1);
15145 fail(runString);
15146 return;
15147 } catch (Throwable e) {
15148 if (e.getClass() != java.lang.NullPointerException.class) {
15149 fail(runString, e);
15150 return;
15151 }
15152 }
15153 } catch (Throwable t) {
15154 fail(runString, t);
15155 return;
15156 }
15157 pass();
15158 }
15159
15160 static void jtt_except_Throw_Synchronized01() {
15161 begin("jtt.except.Throw_Synchronized01");
15162 String runString = null;
15163 try {
15164 // (0) == true
15165 runString = "(0)";
15166 if (true != jtt.except.Throw_Synchronized01.test(0)) {
15167 fail(runString);
15168 return;
15169 }
15170 // (1) == !java.lang.Exception
15171 try {
15172 runString = "(1)";
15173 jtt.except.Throw_Synchronized01.test(1);
15174 fail(runString);
15175 return;
15176 } catch (Throwable e) {
15177 if (e.getClass() != java.lang.Exception.class) {
15178 fail(runString, e);
15179 return;
15180 }
15181 }
15182 } catch (Throwable t) {
15183 fail(runString, t);
15184 return;
15185 }
15186 pass();
15187 }
15188
15189 static void jtt_except_Throw_Synchronized02() {
15190 begin("jtt.except.Throw_Synchronized02");
15191 String runString = null;
15192 try {
15193 // (0) == true
15194 runString = "(0)";
15195 if (true != jtt.except.Throw_Synchronized02.test(0)) {
15196 fail(runString);
15197 return;
15198 }
15199 // (1) == !java.lang.Exception
15200 try {
15201 runString = "(1)";
15202 jtt.except.Throw_Synchronized02.test(1);
15203 fail(runString);
15204 return;
15205 } catch (Throwable e) {
15206 if (e.getClass() != java.lang.Exception.class) {
15207 fail(runString, e);
15208 return;
15209 }
15210 }
15211 } catch (Throwable t) {
15212 fail(runString, t);
15213 return;
15214 }
15215 pass();
15216 }
15217
15218 static void jtt_except_Throw_Synchronized03() {
15219 begin("jtt.except.Throw_Synchronized03");
15220 String runString = null;
15221 try {
15222 // (0) == true
15223 runString = "(0)";
15224 if (true != jtt.except.Throw_Synchronized03.test(0)) {
15225 fail(runString);
15226 return;
15227 }
15228 // (1) == !java.lang.Exception
15229 try {
15230 runString = "(1)";
15231 jtt.except.Throw_Synchronized03.test(1);
15232 fail(runString);
15233 return;
15234 } catch (Throwable e) {
15235 if (e.getClass() != java.lang.Exception.class) {
15236 fail(runString, e);
15237 return;
15238 }
15239 }
15240 } catch (Throwable t) {
15241 fail(runString, t);
15242 return;
15243 }
15244 pass();
15245 }
15246
15247 static void jtt_except_Throw_Synchronized04() {
15248 begin("jtt.except.Throw_Synchronized04");
15249 String runString = null;
15250 try {
15251 // (0) == true
15252 runString = "(0)";
15253 if (true != jtt.except.Throw_Synchronized04.test(0)) {
15254 fail(runString);
15255 return;
15256 }
15257 // (1) == !java.lang.Exception
15258 try {
15259 runString = "(1)";
15260 jtt.except.Throw_Synchronized04.test(1);
15261 fail(runString);
15262 return;
15263 } catch (Throwable e) {
15264 if (e.getClass() != java.lang.Exception.class) {
15265 fail(runString, e);
15266 return;
15267 }
15268 }
15269 } catch (Throwable t) {
15270 fail(runString, t);
15271 return;
15272 }
15273 pass();
15274 }
15275
15276 static void jtt_except_Throw_Synchronized05() {
15277 begin("jtt.except.Throw_Synchronized05");
15278 String runString = null;
15279 try {
15280 // (0) == true
15281 runString = "(0)";
15282 if (true != jtt.except.Throw_Synchronized05.test(0)) {
15283 fail(runString);
15284 return;
15285 }
15286 // (1) == !java.lang.Exception
15287 try {
15288 runString = "(1)";
15289 jtt.except.Throw_Synchronized05.test(1);
15290 fail(runString);
15291 return;
15292 } catch (Throwable e) {
15293 if (e.getClass() != java.lang.Exception.class) {
15294 fail(runString, e);
15295 return;
15296 }
15297 }
15298 } catch (Throwable t) {
15299 fail(runString, t);
15300 return;
15301 }
15302 pass();
15303 }
15304
15305 static void jtt_lang_Boxed_TYPE_01() {
15306 begin("jtt.lang.Boxed_TYPE_01");
15307 String runString = null;
15308 try {
15309 // (0) == "boolean"
15310 runString = "(0)";
15311 if (!"boolean".equals(jtt.lang.Boxed_TYPE_01.test(0))) {
15312 fail(runString);
15313 return;
15314 }
15315 // (1) == "byte"
15316 runString = "(1)";
15317 if (!"byte".equals(jtt.lang.Boxed_TYPE_01.test(1))) {
15318 fail(runString);
15319 return;
15320 }
15321 // (2) == "char"
15322 runString = "(2)";
15323 if (!"char".equals(jtt.lang.Boxed_TYPE_01.test(2))) {
15324 fail(runString);
15325 return;
15326 }
15327 // (3) == "double"
15328 runString = "(3)";
15329 if (!"double".equals(jtt.lang.Boxed_TYPE_01.test(3))) {
15330 fail(runString);
15331 return;
15332 }
15333 // (4) == "float"
15334 runString = "(4)";
15335 if (!"float".equals(jtt.lang.Boxed_TYPE_01.test(4))) {
15336 fail(runString);
15337 return;
15338 }
15339 // (5) == "int"
15340 runString = "(5)";
15341 if (!"int".equals(jtt.lang.Boxed_TYPE_01.test(5))) {
15342 fail(runString);
15343 return;
15344 }
15345 // (6) == "long"
15346 runString = "(6)";
15347 if (!"long".equals(jtt.lang.Boxed_TYPE_01.test(6))) {
15348 fail(runString);
15349 return;
15350 }
15351 // (7) == "short"
15352 runString = "(7)";
15353 if (!"short".equals(jtt.lang.Boxed_TYPE_01.test(7))) {
15354 fail(runString);
15355 return;
15356 }
15357 // (8) == "void"
15358 runString = "(8)";
15359 if (!"void".equals(jtt.lang.Boxed_TYPE_01.test(8))) {
15360 fail(runString);
15361 return;
15362 }
15363 } catch (Throwable t) {
15364 fail(runString, t);
15365 return;
15366 }
15367 pass();
15368 }
15369
15370 static void jtt_lang_Bridge_method01() {
15371 begin("jtt.lang.Bridge_method01");
15372 String runString = null;
15373 try {
15374 // (0) == 1
15375 runString = "(0)";
15376 if (1 != jtt.lang.Bridge_method01.test(0)) {
15377 fail(runString);
15378 return;
15379 }
15380 // (1) == 1
15381 runString = "(1)";
15382 if (1 != jtt.lang.Bridge_method01.test(1)) {
15383 fail(runString);
15384 return;
15385 }
15386 } catch (Throwable t) {
15387 fail(runString, t);
15388 return;
15389 }
15390 pass();
15391 }
15392
15393 static void jtt_lang_ClassLoader_loadClass01() {
15394 begin("jtt.lang.ClassLoader_loadClass01");
15395 String runString = null;
15396 try {
15397 // (0) == "class java.lang.String"
15398 runString = "(0)";
15399 if (!"class java.lang.String"
15400 .equals(jtt.lang.ClassLoader_loadClass01.test(0))) {
15401 fail(runString);
15402 return;
15403 }
15404 // (1) == !java.lang.ClassNotFoundException
15405 try {
15406 runString = "(1)";
15407 jtt.lang.ClassLoader_loadClass01.test(1);
15408 fail(runString);
15409 return;
15410 } catch (Throwable e) {
15411 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15412 fail(runString, e);
15413 return;
15414 }
15415 }
15416 // (2) == !java.lang.ClassNotFoundException
15417 try {
15418 runString = "(2)";
15419 jtt.lang.ClassLoader_loadClass01.test(2);
15420 fail(runString);
15421 return;
15422 } catch (Throwable e) {
15423 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15424 fail(runString, e);
15425 return;
15426 }
15427 }
15428 } catch (Throwable t) {
15429 fail(runString, t);
15430 return;
15431 }
15432 pass();
15433 }
15434
15435 static void jtt_lang_Class_Literal01() {
15436 begin("jtt.lang.Class_Literal01");
15437 String runString = null;
15438 try {
15439 // (0) == "class java.lang.Object"
15440 runString = "(0)";
15441 if (!"class java.lang.Object".equals(jtt.lang.Class_Literal01
15442 .test(0))) {
15443 fail(runString);
15444 return;
15445 }
15446 // (1) == "class java.lang.String"
15447 runString = "(1)";
15448 if (!"class java.lang.String".equals(jtt.lang.Class_Literal01
15449 .test(1))) {
15450 fail(runString);
15451 return;
15452 }
15453 // (2) == "class java.lang.Class"
15454 runString = "(2)";
15455 if (!"class java.lang.Class".equals(jtt.lang.Class_Literal01
15456 .test(2))) {
15457 fail(runString);
15458 return;
15459 }
15460 // (3) == "class jtt.lang.Class_Literal01"
15461 runString = "(3)";
15462 if (!"class jtt.lang.Class_Literal01"
15463 .equals(jtt.lang.Class_Literal01.test(3))) {
15464 fail(runString);
15465 return;
15466 }
15467 // (4) == null
15468 runString = "(4)";
15469 if (null != jtt.lang.Class_Literal01.test(4)) {
15470 fail(runString);
15471 return;
15472 }
15473 } catch (Throwable t) {
15474 fail(runString, t);
15475 return;
15476 }
15477 pass();
15478 }
15479
15480 static void jtt_lang_Class_asSubclass01() {
15481 begin("jtt.lang.Class_asSubclass01");
15482 String runString = null;
15483 try {
15484 // (0) == !java.lang.ClassCastException
15485 try {
15486 runString = "(0)";
15487 jtt.lang.Class_asSubclass01.test(0);
15488 fail(runString);
15489 return;
15490 } catch (Throwable e) {
15491 if (e.getClass() != java.lang.ClassCastException.class) {
15492 fail(runString, e);
15493 return;
15494 }
15495 }
15496 // (1) == 1
15497 runString = "(1)";
15498 if (1 != jtt.lang.Class_asSubclass01.test(1)) {
15499 fail(runString);
15500 return;
15501 }
15502 // (2) == !java.lang.ClassCastException
15503 try {
15504 runString = "(2)";
15505 jtt.lang.Class_asSubclass01.test(2);
15506 fail(runString);
15507 return;
15508 } catch (Throwable e) {
15509 if (e.getClass() != java.lang.ClassCastException.class) {
15510 fail(runString, e);
15511 return;
15512 }
15513 }
15514 // (3) == 3
15515 runString = "(3)";
15516 if (3 != jtt.lang.Class_asSubclass01.test(3)) {
15517 fail(runString);
15518 return;
15519 }
15520 // (4) == 4
15521 runString = "(4)";
15522 if (4 != jtt.lang.Class_asSubclass01.test(4)) {
15523 fail(runString);
15524 return;
15525 }
15526 } catch (Throwable t) {
15527 fail(runString, t);
15528 return;
15529 }
15530 pass();
15531 }
15532
15533 static void jtt_lang_Class_cast01() {
15534 begin("jtt.lang.Class_cast01");
15535 String runString = null;
15536 try {
15537 // (1) == !java.lang.ClassCastException
15538 try {
15539 runString = "(1)";
15540 jtt.lang.Class_cast01.test(1);
15541 fail(runString);
15542 return;
15543 } catch (Throwable e) {
15544 if (e.getClass() != java.lang.ClassCastException.class) {
15545 fail(runString, e);
15546 return;
15547 }
15548 }
15549 // (0) == 0
15550 runString = "(0)";
15551 if (0 != jtt.lang.Class_cast01.test(0)) {
15552 fail(runString);
15553 return;
15554 }
15555 // (3) == !java.lang.ClassCastException
15556 try {
15557 runString = "(3)";
15558 jtt.lang.Class_cast01.test(3);
15559 fail(runString);
15560 return;
15561 } catch (Throwable e) {
15562 if (e.getClass() != java.lang.ClassCastException.class) {
15563 fail(runString, e);
15564 return;
15565 }
15566 }
15567 // (2) == 2
15568 runString = "(2)";
15569 if (2 != jtt.lang.Class_cast01.test(2)) {
15570 fail(runString);
15571 return;
15572 }
15573 // (4) == 4
15574 runString = "(4)";
15575 if (4 != jtt.lang.Class_cast01.test(4)) {
15576 fail(runString);
15577 return;
15578 }
15579 } catch (Throwable t) {
15580 fail(runString, t);
15581 return;
15582 }
15583 pass();
15584 }
15585
15586 static void jtt_lang_Class_cast02() {
15587 begin("jtt.lang.Class_cast02");
15588 String runString = null;
15589 try {
15590 // (0) == -1
15591 runString = "(0)";
15592 if (-1 != jtt.lang.Class_cast02.test(0)) {
15593 fail(runString);
15594 return;
15595 }
15596 // (1) == -1
15597 runString = "(1)";
15598 if (-1 != jtt.lang.Class_cast02.test(1)) {
15599 fail(runString);
15600 return;
15601 }
15602 // (2) == -1
15603 runString = "(2)";
15604 if (-1 != jtt.lang.Class_cast02.test(2)) {
15605 fail(runString);
15606 return;
15607 }
15608 // (3) == -1
15609 runString = "(3)";
15610 if (-1 != jtt.lang.Class_cast02.test(3)) {
15611 fail(runString);
15612 return;
15613 }
15614 // (4) == 4
15615 runString = "(4)";
15616 if (4 != jtt.lang.Class_cast02.test(4)) {
15617 fail(runString);
15618 return;
15619 }
15620 } catch (Throwable t) {
15621 fail(runString, t);
15622 return;
15623 }
15624 pass();
15625 }
15626
15627 static void jtt_lang_Class_forName01() {
15628 begin("jtt.lang.Class_forName01");
15629 String runString = null;
15630 try {
15631 // (0) == "class java.lang.Object"
15632 runString = "(0)";
15633 if (!"class java.lang.Object".equals(jtt.lang.Class_forName01
15634 .test(0))) {
15635 fail(runString);
15636 return;
15637 }
15638 // (1) == "class java.lang.String"
15639 runString = "(1)";
15640 if (!"class java.lang.String".equals(jtt.lang.Class_forName01
15641 .test(1))) {
15642 fail(runString);
15643 return;
15644 }
15645 // (2) == "class jtt.lang.Class_forName01"
15646 runString = "(2)";
15647 if (!"class jtt.lang.Class_forName01"
15648 .equals(jtt.lang.Class_forName01.test(2))) {
15649 fail(runString);
15650 return;
15651 }
15652 // (3) == !java.lang.ClassNotFoundException
15653 try {
15654 runString = "(3)";
15655 jtt.lang.Class_forName01.test(3);
15656 fail(runString);
15657 return;
15658 } catch (Throwable e) {
15659 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15660 fail(runString, e);
15661 return;
15662 }
15663 }
15664 } catch (Throwable t) {
15665 fail(runString, t);
15666 return;
15667 }
15668 pass();
15669 }
15670
15671 static void jtt_lang_Class_forName02() {
15672 begin("jtt.lang.Class_forName02");
15673 String runString = null;
15674 try {
15675 // (0) == "class java.lang.Object"
15676 runString = "(0)";
15677 if (!"class java.lang.Object".equals(jtt.lang.Class_forName02
15678 .test(0))) {
15679 fail(runString);
15680 return;
15681 }
15682 // (1) == "class java.lang.String"
15683 runString = "(1)";
15684 if (!"class java.lang.String".equals(jtt.lang.Class_forName02
15685 .test(1))) {
15686 fail(runString);
15687 return;
15688 }
15689 // (2) == "class jtt.lang.Class_forName02"
15690 runString = "(2)";
15691 if (!"class jtt.lang.Class_forName02"
15692 .equals(jtt.lang.Class_forName02.test(2))) {
15693 fail(runString);
15694 return;
15695 }
15696 // (3) == !java.lang.ClassNotFoundException
15697 try {
15698 runString = "(3)";
15699 jtt.lang.Class_forName02.test(3);
15700 fail(runString);
15701 return;
15702 } catch (Throwable e) {
15703 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15704 fail(runString, e);
15705 return;
15706 }
15707 }
15708 } catch (Throwable t) {
15709 fail(runString, t);
15710 return;
15711 }
15712 pass();
15713 }
15714
15715 static void jtt_lang_Class_forName03() {
15716 begin("jtt.lang.Class_forName03");
15717 String runString = null;
15718 try {
15719 // (0) == !java.lang.ClassNotFoundException
15720 try {
15721 runString = "(0)";
15722 jtt.lang.Class_forName03.test(0);
15723 fail(runString);
15724 return;
15725 } catch (Throwable e) {
15726 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15727 fail(runString, e);
15728 return;
15729 }
15730 }
15731 // (1) == "class [Ljava.lang.String;"
15732 runString = "(1)";
15733 if (!"class [Ljava.lang.String;".equals(jtt.lang.Class_forName03
15734 .test(1))) {
15735 fail(runString);
15736 return;
15737 }
15738 // (2) == !java.lang.ClassNotFoundException
15739 try {
15740 runString = "(2)";
15741 jtt.lang.Class_forName03.test(2);
15742 fail(runString);
15743 return;
15744 } catch (Throwable e) {
15745 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15746 fail(runString, e);
15747 return;
15748 }
15749 }
15750 // (3) == "class [I"
15751 runString = "(3)";
15752 if (!"class [I".equals(jtt.lang.Class_forName03.test(3))) {
15753 fail(runString);
15754 return;
15755 }
15756 // (4) == !java.lang.ClassNotFoundException
15757 try {
15758 runString = "(4)";
15759 jtt.lang.Class_forName03.test(4);
15760 fail(runString);
15761 return;
15762 } catch (Throwable e) {
15763 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15764 fail(runString, e);
15765 return;
15766 }
15767 }
15768 // (5) == null
15769 runString = "(5)";
15770 if (null != jtt.lang.Class_forName03.test(5)) {
15771 fail(runString);
15772 return;
15773 }
15774 } catch (Throwable t) {
15775 fail(runString, t);
15776 return;
15777 }
15778 pass();
15779 }
15780
15781 static void jtt_lang_Class_forName04() {
15782 begin("jtt.lang.Class_forName04");
15783 String runString = null;
15784 try {
15785 // (0) == !java.lang.ClassNotFoundException
15786 try {
15787 runString = "(0)";
15788 jtt.lang.Class_forName04.test(0);
15789 fail(runString);
15790 return;
15791 } catch (Throwable e) {
15792 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15793 fail(runString, e);
15794 return;
15795 }
15796 }
15797 // (1) == "class [Ljava.lang.String;"
15798 runString = "(1)";
15799 if (!"class [Ljava.lang.String;".equals(jtt.lang.Class_forName04
15800 .test(1))) {
15801 fail(runString);
15802 return;
15803 }
15804 // (2) == !java.lang.ClassNotFoundException
15805 try {
15806 runString = "(2)";
15807 jtt.lang.Class_forName04.test(2);
15808 fail(runString);
15809 return;
15810 } catch (Throwable e) {
15811 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15812 fail(runString, e);
15813 return;
15814 }
15815 }
15816 // (3) == "class [I"
15817 runString = "(3)";
15818 if (!"class [I".equals(jtt.lang.Class_forName04.test(3))) {
15819 fail(runString);
15820 return;
15821 }
15822 // (4) == !java.lang.ClassNotFoundException
15823 try {
15824 runString = "(4)";
15825 jtt.lang.Class_forName04.test(4);
15826 fail(runString);
15827 return;
15828 } catch (Throwable e) {
15829 if (e.getClass() != java.lang.ClassNotFoundException.class) {
15830 fail(runString, e);
15831 return;
15832 }
15833 }
15834 // (5) == null
15835 runString = "(5)";
15836 if (null != jtt.lang.Class_forName04.test(5)) {
15837 fail(runString);
15838 return;
15839 }
15840 } catch (Throwable t) {
15841 fail(runString, t);
15842 return;
15843 }
15844 pass();
15845 }
15846
15847 static void jtt_lang_Class_forName05() {
15848 begin("jtt.lang.Class_forName05");
15849 String runString = null;
15850 try {
15851 // (0) == "class java.lang.String"
15852 runString = "(0)";
15853 if (!"class java.lang.String".equals(jtt.lang.Class_forName05
15854 .test(0))) {
15855 fail(runString);
15856 return;
15857 }
15858 // (1) == "class [Ljava.lang.String;"
15859 runString = "(1)";
15860 if (!"class [Ljava.lang.String;".equals(jtt.lang.Class_forName05
15861 .test(1))) {
15862 fail(runString);
15863 return;
15864 }
15865 // (5) == null
15866 runString = "(5)";
15867 if (null != jtt.lang.Class_forName05.test(5)) {
15868 fail(runString);
15869 return;
15870 }
15871 } catch (Throwable t) {
15872 fail(runString, t);
15873 return;
15874 }
15875 pass();
15876 }
15877
15878 static void jtt_lang_Class_getComponentType01() {
15879 begin("jtt.lang.Class_getComponentType01");
15880 String runString = null;
15881 try {
15882 // (0) == null
15883 runString = "(0)";
15884 if (null != jtt.lang.Class_getComponentType01.test(0)) {
15885 fail(runString);
15886 return;
15887 }
15888 // (1) == "int"
15889 runString = "(1)";
15890 if (!"int".equals(jtt.lang.Class_getComponentType01.test(1))) {
15891 fail(runString);
15892 return;
15893 }
15894 // (2) == null
15895 runString = "(2)";
15896 if (null != jtt.lang.Class_getComponentType01.test(2)) {
15897 fail(runString);
15898 return;
15899 }
15900 // (3) == "java.lang.Object"
15901 runString = "(3)";
15902 if (!"java.lang.Object".equals(jtt.lang.Class_getComponentType01
15903 .test(3))) {
15904 fail(runString);
15905 return;
15906 }
15907 // (4) == null
15908 runString = "(4)";
15909 if (null != jtt.lang.Class_getComponentType01.test(4)) {
15910 fail(runString);
15911 return;
15912 }
15913 // (5) == null
15914 runString = "(5)";
15915 if (null != jtt.lang.Class_getComponentType01.test(5)) {
15916 fail(runString);
15917 return;
15918 }
15919 // (6) == "[Ljava.lang.Object;"
15920 runString = "(6)";
15921 if (!"[Ljava.lang.Object;".equals(jtt.lang.Class_getComponentType01
15922 .test(6))) {
15923 fail(runString);
15924 return;
15925 }
15926 // (7) == null
15927 runString = "(7)";
15928 if (null != jtt.lang.Class_getComponentType01.test(7)) {
15929 fail(runString);
15930 return;
15931 }
15932 // (8) == null
15933 runString = "(8)";
15934 if (null != jtt.lang.Class_getComponentType01.test(8)) {
15935 fail(runString);
15936 return;
15937 }
15938 } catch (Throwable t) {
15939 fail(runString, t);
15940 return;
15941 }
15942 pass();
15943 }
15944
15945 static void jtt_lang_Class_getInterfaces01() {
15946 begin("jtt.lang.Class_getInterfaces01");
15947 String runString = null;
15948 try {
15949 // (0) == ""
15950 runString = "(0)";
15951 if (!"".equals(jtt.lang.Class_getInterfaces01.test(0))) {
15952 fail(runString);
15953 return;
15954 }
15955 // (1) == "jtt.lang.Class_getInterfaces01$I1"
15956 runString = "(1)";
15957 if (!"jtt.lang.Class_getInterfaces01$I1"
15958 .equals(jtt.lang.Class_getInterfaces01.test(1))) {
15959 fail(runString);
15960 return;
15961 }
15962 // (2) == "jtt.lang.Class_getInterfaces01$I1"
15963 runString = "(2)";
15964 if (!"jtt.lang.Class_getInterfaces01$I1"
15965 .equals(jtt.lang.Class_getInterfaces01.test(2))) {
15966 fail(runString);
15967 return;
15968 }
15969 // (3) == "jtt.lang.Class_getInterfaces01$I2"
15970 runString = "(3)";
15971 if (!"jtt.lang.Class_getInterfaces01$I2"
15972 .equals(jtt.lang.Class_getInterfaces01.test(3))) {
15973 fail(runString);
15974 return;
15975 }
15976 // (4) ==
15977 // "jtt.lang.Class_getInterfaces01$I1 jtt.lang.Class_getInterfaces01$I2"
15978 runString = "(4)";
15979 if (!"jtt.lang.Class_getInterfaces01$I1 jtt.lang.Class_getInterfaces01$I2"
15980 .equals(jtt.lang.Class_getInterfaces01.test(4))) {
15981 fail(runString);
15982 return;
15983 }
15984 } catch (Throwable t) {
15985 fail(runString, t);
15986 return;
15987 }
15988 pass();
15989 }
15990
15991 static void jtt_lang_Class_getName01() {
15992 begin("jtt.lang.Class_getName01");
15993 String runString = null;
15994 try {
15995 // (0) == "java.lang.Object"
15996 runString = "(0)";
15997 if (!"java.lang.Object".equals(jtt.lang.Class_getName01.test(0))) {
15998 fail(runString);
15999 return;
16000 }
16001 // (1) == "java.lang.Class"
16002 runString = "(1)";
16003 if (!"java.lang.Class".equals(jtt.lang.Class_getName01.test(1))) {
16004 fail(runString);
16005 return;
16006 }
16007 // (2) == "jtt.lang.Class_getName01"
16008 runString = "(2)";
16009 if (!"jtt.lang.Class_getName01".equals(jtt.lang.Class_getName01
16010 .test(2))) {
16011 fail(runString);
16012 return;
16013 }
16014 // (3) == "true"
16015 runString = "(3)";
16016 if (!"true".equals(jtt.lang.Class_getName01.test(3))) {
16017 fail(runString);
16018 return;
16019 }
16020 // (4) == null
16021 runString = "(4)";
16022 if (null != jtt.lang.Class_getName01.test(4)) {
16023 fail(runString);
16024 return;
16025 }
16026 } catch (Throwable t) {
16027 fail(runString, t);
16028 return;
16029 }
16030 pass();
16031 }
16032
16033 static void jtt_lang_Class_getName02() {
16034 begin("jtt.lang.Class_getName02");
16035 String runString = null;
16036 try {
16037 // (0) == "int"
16038 runString = "(0)";
16039 if (!"int".equals(jtt.lang.Class_getName02.test(0))) {
16040 fail(runString);
16041 return;
16042 }
16043 // (1) == "[I"
16044 runString = "(1)";
16045 if (!"[I".equals(jtt.lang.Class_getName02.test(1))) {
16046 fail(runString);
16047 return;
16048 }
16049 // (2) == "[[Ljava.lang.Object;"
16050 runString = "(2)";
16051 if (!"[[Ljava.lang.Object;"
16052 .equals(jtt.lang.Class_getName02.test(2))) {
16053 fail(runString);
16054 return;
16055 }
16056 // (3) == null
16057 runString = "(3)";
16058 if (null != jtt.lang.Class_getName02.test(3)) {
16059 fail(runString);
16060 return;
16061 }
16062 } catch (Throwable t) {
16063 fail(runString, t);
16064 return;
16065 }
16066 pass();
16067 }
16068
16069 static void jtt_lang_Class_getSimpleName01() {
16070 begin("jtt.lang.Class_getSimpleName01");
16071 String runString = null;
16072 try {
16073 // (0) == "Object"
16074 runString = "(0)";
16075 if (!"Object".equals(jtt.lang.Class_getSimpleName01.test(0))) {
16076 fail(runString);
16077 return;
16078 }
16079 // (1) == "Class"
16080 runString = "(1)";
16081 if (!"Class".equals(jtt.lang.Class_getSimpleName01.test(1))) {
16082 fail(runString);
16083 return;
16084 }
16085 // (2) == "Class_getSimpleName01"
16086 runString = "(2)";
16087 if (!"Class_getSimpleName01".equals(jtt.lang.Class_getSimpleName01
16088 .test(2))) {
16089 fail(runString);
16090 return;
16091 }
16092 // (3) == null
16093 runString = "(3)";
16094 if (null != jtt.lang.Class_getSimpleName01.test(3)) {
16095 fail(runString);
16096 return;
16097 }
16098 } catch (Throwable t) {
16099 fail(runString, t);
16100 return;
16101 }
16102 pass();
16103 }
16104
16105 static void jtt_lang_Class_getSimpleName02() {
16106 begin("jtt.lang.Class_getSimpleName02");
16107 String runString = null;
16108 try {
16109 // (0) == "int"
16110 runString = "(0)";
16111 if (!"int".equals(jtt.lang.Class_getSimpleName02.test(0))) {
16112 fail(runString);
16113 return;
16114 }
16115 // (1) == "int[]"
16116 runString = "(1)";
16117 if (!"int[]".equals(jtt.lang.Class_getSimpleName02.test(1))) {
16118 fail(runString);
16119 return;
16120 }
16121 // (2) == "Object[][]"
16122 runString = "(2)";
16123 if (!"Object[][]".equals(jtt.lang.Class_getSimpleName02.test(2))) {
16124 fail(runString);
16125 return;
16126 }
16127 // (3) == null
16128 runString = "(3)";
16129 if (null != jtt.lang.Class_getSimpleName02.test(3)) {
16130 fail(runString);
16131 return;
16132 }
16133 } catch (Throwable t) {
16134 fail(runString, t);
16135 return;
16136 }
16137 pass();
16138 }
16139
16140 static void jtt_lang_Class_getSuperClass01() {
16141 begin("jtt.lang.Class_getSuperClass01");
16142 String runString = null;
16143 try {
16144 // (0) == null
16145 runString = "(0)";
16146 if (null != jtt.lang.Class_getSuperClass01.test(0)) {
16147 fail(runString);
16148 return;
16149 }
16150 // (1) == null
16151 runString = "(1)";
16152 if (null != jtt.lang.Class_getSuperClass01.test(1)) {
16153 fail(runString);
16154 return;
16155 }
16156 // (2) == "java.lang.Object"
16157 runString = "(2)";
16158 if (!"java.lang.Object".equals(jtt.lang.Class_getSuperClass01
16159 .test(2))) {
16160 fail(runString);
16161 return;
16162 }
16163 // (3) == null
16164 runString = "(3)";
16165 if (null != jtt.lang.Class_getSuperClass01.test(3)) {
16166 fail(runString);
16167 return;
16168 }
16169 // (4) == "java.lang.Number"
16170 runString = "(4)";
16171 if (!"java.lang.Number".equals(jtt.lang.Class_getSuperClass01
16172 .test(4))) {
16173 fail(runString);
16174 return;
16175 }
16176 // (5) == "java.lang.Object"
16177 runString = "(5)";
16178 if (!"java.lang.Object".equals(jtt.lang.Class_getSuperClass01
16179 .test(5))) {
16180 fail(runString);
16181 return;
16182 }
16183 // (6) == "java.lang.Object"
16184 runString = "(6)";
16185 if (!"java.lang.Object".equals(jtt.lang.Class_getSuperClass01
16186 .test(6))) {
16187 fail(runString);
16188 return;
16189 }
16190 // (7) == null
16191 runString = "(7)";
16192 if (null != jtt.lang.Class_getSuperClass01.test(7)) {
16193 fail(runString);
16194 return;
16195 }
16196 } catch (Throwable t) {
16197 fail(runString, t);
16198 return;
16199 }
16200 pass();
16201 }
16202
16203 static void jtt_lang_Class_isArray01() {
16204 begin("jtt.lang.Class_isArray01");
16205 String runString = null;
16206 try {
16207 // (0) == false
16208 runString = "(0)";
16209 if (false != jtt.lang.Class_isArray01.test(0)) {
16210 fail(runString);
16211 return;
16212 }
16213 // (1) == true
16214 runString = "(1)";
16215 if (true != jtt.lang.Class_isArray01.test(1)) {
16216 fail(runString);
16217 return;
16218 }
16219 // (2) == false
16220 runString = "(2)";
16221 if (false != jtt.lang.Class_isArray01.test(2)) {
16222 fail(runString);
16223 return;
16224 }
16225 // (3) == true
16226 runString = "(3)";
16227 if (true != jtt.lang.Class_isArray01.test(3)) {
16228 fail(runString);
16229 return;
16230 }
16231 // (4) == false
16232 runString = "(4)";
16233 if (false != jtt.lang.Class_isArray01.test(4)) {
16234 fail(runString);
16235 return;
16236 }
16237 // (5) == false
16238 runString = "(5)";
16239 if (false != jtt.lang.Class_isArray01.test(5)) {
16240 fail(runString);
16241 return;
16242 }
16243 // (6) == false
16244 runString = "(6)";
16245 if (false != jtt.lang.Class_isArray01.test(6)) {
16246 fail(runString);
16247 return;
16248 }
16249 // (7) == false
16250 runString = "(7)";
16251 if (false != jtt.lang.Class_isArray01.test(7)) {
16252 fail(runString);
16253 return;
16254 }
16255 // (8) == false
16256 runString = "(8)";
16257 if (false != jtt.lang.Class_isArray01.test(8)) {
16258 fail(runString);
16259 return;
16260 }
16261 } catch (Throwable t) {
16262 fail(runString, t);
16263 return;
16264 }
16265 pass();
16266 }
16267
16268 static void jtt_lang_Class_isAssignableFrom01() {
16269 begin("jtt.lang.Class_isAssignableFrom01");
16270 String runString = null;
16271 try {
16272 // (0) == true
16273 runString = "(0)";
16274 if (true != jtt.lang.Class_isAssignableFrom01.test(0)) {
16275 fail(runString);
16276 return;
16277 }
16278 // (1) == false
16279 runString = "(1)";
16280 if (false != jtt.lang.Class_isAssignableFrom01.test(1)) {
16281 fail(runString);
16282 return;
16283 }
16284 // (2) == false
16285 runString = "(2)";
16286 if (false != jtt.lang.Class_isAssignableFrom01.test(2)) {
16287 fail(runString);
16288 return;
16289 }
16290 // (3) == false
16291 runString = "(3)";
16292 if (false != jtt.lang.Class_isAssignableFrom01.test(3)) {
16293 fail(runString);
16294 return;
16295 }
16296 // (4) == false
16297 runString = "(4)";
16298 if (false != jtt.lang.Class_isAssignableFrom01.test(4)) {
16299 fail(runString);
16300 return;
16301 }
16302 // (5) == false
16303 runString = "(5)";
16304 if (false != jtt.lang.Class_isAssignableFrom01.test(5)) {
16305 fail(runString);
16306 return;
16307 }
16308 // (6) == false
16309 runString = "(6)";
16310 if (false != jtt.lang.Class_isAssignableFrom01.test(6)) {
16311 fail(runString);
16312 return;
16313 }
16314 // (7) == false
16315 runString = "(7)";
16316 if (false != jtt.lang.Class_isAssignableFrom01.test(7)) {
16317 fail(runString);
16318 return;
16319 }
16320 } catch (Throwable t) {
16321 fail(runString, t);
16322 return;
16323 }
16324 pass();
16325 }
16326
16327 static void jtt_lang_Class_isAssignableFrom02() {
16328 begin("jtt.lang.Class_isAssignableFrom02");
16329 String runString = null;
16330 try {
16331 // (0) == false
16332 runString = "(0)";
16333 if (false != jtt.lang.Class_isAssignableFrom02.test(0)) {
16334 fail(runString);
16335 return;
16336 }
16337 // (1) == true
16338 runString = "(1)";
16339 if (true != jtt.lang.Class_isAssignableFrom02.test(1)) {
16340 fail(runString);
16341 return;
16342 }
16343 // (2) == false
16344 runString = "(2)";
16345 if (false != jtt.lang.Class_isAssignableFrom02.test(2)) {
16346 fail(runString);
16347 return;
16348 }
16349 // (3) == false
16350 runString = "(3)";
16351 if (false != jtt.lang.Class_isAssignableFrom02.test(3)) {
16352 fail(runString);
16353 return;
16354 }
16355 // (4) == true
16356 runString = "(4)";
16357 if (true != jtt.lang.Class_isAssignableFrom02.test(4)) {
16358 fail(runString);
16359 return;
16360 }
16361 // (5) == true
16362 runString = "(5)";
16363 if (true != jtt.lang.Class_isAssignableFrom02.test(5)) {
16364 fail(runString);
16365 return;
16366 }
16367 // (6) == true
16368 runString = "(6)";
16369 if (true != jtt.lang.Class_isAssignableFrom02.test(6)) {
16370 fail(runString);
16371 return;
16372 }
16373 // (7) == true
16374 runString = "(7)";
16375 if (true != jtt.lang.Class_isAssignableFrom02.test(7)) {
16376 fail(runString);
16377 return;
16378 }
16379 } catch (Throwable t) {
16380 fail(runString, t);
16381 return;
16382 }
16383 pass();
16384 }
16385
16386 static void jtt_lang_Class_isAssignableFrom03() {
16387 begin("jtt.lang.Class_isAssignableFrom03");
16388 String runString = null;
16389 try {
16390 // (0) == false
16391 runString = "(0)";
16392 if (false != jtt.lang.Class_isAssignableFrom03.test(0)) {
16393 fail(runString);
16394 return;
16395 }
16396 // (1) == true
16397 runString = "(1)";
16398 if (true != jtt.lang.Class_isAssignableFrom03.test(1)) {
16399 fail(runString);
16400 return;
16401 }
16402 // (2) == false
16403 runString = "(2)";
16404 if (false != jtt.lang.Class_isAssignableFrom03.test(2)) {
16405 fail(runString);
16406 return;
16407 }
16408 // (3) == true
16409 runString = "(3)";
16410 if (true != jtt.lang.Class_isAssignableFrom03.test(3)) {
16411 fail(runString);
16412 return;
16413 }
16414 // (4) == false
16415 runString = "(4)";
16416 if (false != jtt.lang.Class_isAssignableFrom03.test(4)) {
16417 fail(runString);
16418 return;
16419 }
16420 // (5) == true
16421 runString = "(5)";
16422 if (true != jtt.lang.Class_isAssignableFrom03.test(5)) {
16423 fail(runString);
16424 return;
16425 }
16426 // (6) == true
16427 runString = "(6)";
16428 if (true != jtt.lang.Class_isAssignableFrom03.test(6)) {
16429 fail(runString);
16430 return;
16431 }
16432 // (7) == false
16433 runString = "(7)";
16434 if (false != jtt.lang.Class_isAssignableFrom03.test(7)) {
16435 fail(runString);
16436 return;
16437 }
16438 } catch (Throwable t) {
16439 fail(runString, t);
16440 return;
16441 }
16442 pass();
16443 }
16444
16445 static void jtt_lang_Class_isInstance01() {
16446 begin("jtt.lang.Class_isInstance01");
16447 String runString = null;
16448 try {
16449 // (0) == true
16450 runString = "(0)";
16451 if (true != jtt.lang.Class_isInstance01.test(0)) {
16452 fail(runString);
16453 return;
16454 }
16455 // (1) == true
16456 runString = "(1)";
16457 if (true != jtt.lang.Class_isInstance01.test(1)) {
16458 fail(runString);
16459 return;
16460 }
16461 // (2) == true
16462 runString = "(2)";
16463 if (true != jtt.lang.Class_isInstance01.test(2)) {
16464 fail(runString);
16465 return;
16466 }
16467 // (3) == false
16468 runString = "(3)";
16469 if (false != jtt.lang.Class_isInstance01.test(3)) {
16470 fail(runString);
16471 return;
16472 }
16473 } catch (Throwable t) {
16474 fail(runString, t);
16475 return;
16476 }
16477 pass();
16478 }
16479
16480 static void jtt_lang_Class_isInstance02() {
16481 begin("jtt.lang.Class_isInstance02");
16482 String runString = null;
16483 try {
16484 // (0) == false
16485 runString = "(0)";
16486 if (false != jtt.lang.Class_isInstance02.test(0)) {
16487 fail(runString);
16488 return;
16489 }
16490 // (1) == true
16491 runString = "(1)";
16492 if (true != jtt.lang.Class_isInstance02.test(1)) {
16493 fail(runString);
16494 return;
16495 }
16496 // (2) == false
16497 runString = "(2)";
16498 if (false != jtt.lang.Class_isInstance02.test(2)) {
16499 fail(runString);
16500 return;
16501 }
16502 // (3) == false
16503 runString = "(3)";
16504 if (false != jtt.lang.Class_isInstance02.test(3)) {
16505 fail(runString);
16506 return;
16507 }
16508 } catch (Throwable t) {
16509 fail(runString, t);
16510 return;
16511 }
16512 pass();
16513 }
16514
16515 static void jtt_lang_Class_isInstance03() {
16516 begin("jtt.lang.Class_isInstance03");
16517 String runString = null;
16518 try {
16519 // (0) == false
16520 runString = "(0)";
16521 if (false != jtt.lang.Class_isInstance03.test(0)) {
16522 fail(runString);
16523 return;
16524 }
16525 // (1) == false
16526 runString = "(1)";
16527 if (false != jtt.lang.Class_isInstance03.test(1)) {
16528 fail(runString);
16529 return;
16530 }
16531 // (2) == true
16532 runString = "(2)";
16533 if (true != jtt.lang.Class_isInstance03.test(2)) {
16534 fail(runString);
16535 return;
16536 }
16537 // (3) == false
16538 runString = "(3)";
16539 if (false != jtt.lang.Class_isInstance03.test(3)) {
16540 fail(runString);
16541 return;
16542 }
16543 } catch (Throwable t) {
16544 fail(runString, t);
16545 return;
16546 }
16547 pass();
16548 }
16549
16550 static void jtt_lang_Class_isInstance04() {
16551 begin("jtt.lang.Class_isInstance04");
16552 String runString = null;
16553 try {
16554 // (0) == false
16555 runString = "(0)";
16556 if (false != jtt.lang.Class_isInstance04.test(0)) {
16557 fail(runString);
16558 return;
16559 }
16560 // (1) == false
16561 runString = "(1)";
16562 if (false != jtt.lang.Class_isInstance04.test(1)) {
16563 fail(runString);
16564 return;
16565 }
16566 // (2) == true
16567 runString = "(2)";
16568 if (true != jtt.lang.Class_isInstance04.test(2)) {
16569 fail(runString);
16570 return;
16571 }
16572 // (3) == false
16573 runString = "(3)";
16574 if (false != jtt.lang.Class_isInstance04.test(3)) {
16575 fail(runString);
16576 return;
16577 }
16578 } catch (Throwable t) {
16579 fail(runString, t);
16580 return;
16581 }
16582 pass();
16583 }
16584
16585 static void jtt_lang_Class_isInstance05() {
16586 begin("jtt.lang.Class_isInstance05");
16587 String runString = null;
16588 try {
16589 // (0) == false
16590 runString = "(0)";
16591 if (false != jtt.lang.Class_isInstance05.test(0)) {
16592 fail(runString);
16593 return;
16594 }
16595 // (1) == false
16596 runString = "(1)";
16597 if (false != jtt.lang.Class_isInstance05.test(1)) {
16598 fail(runString);
16599 return;
16600 }
16601 // (2) == true
16602 runString = "(2)";
16603 if (true != jtt.lang.Class_isInstance05.test(2)) {
16604 fail(runString);
16605 return;
16606 }
16607 // (3) == false
16608 runString = "(3)";
16609 if (false != jtt.lang.Class_isInstance05.test(3)) {
16610 fail(runString);
16611 return;
16612 }
16613 } catch (Throwable t) {
16614 fail(runString, t);
16615 return;
16616 }
16617 pass();
16618 }
16619
16620 static void jtt_lang_Class_isInstance06() {
16621 begin("jtt.lang.Class_isInstance06");
16622 String runString = null;
16623 try {
16624 // (0) == false
16625 runString = "(0)";
16626 if (false != jtt.lang.Class_isInstance06.test(0)) {
16627 fail(runString);
16628 return;
16629 }
16630 // (1) == false
16631 runString = "(1)";
16632 if (false != jtt.lang.Class_isInstance06.test(1)) {
16633 fail(runString);
16634 return;
16635 }
16636 // (2) == true
16637 runString = "(2)";
16638 if (true != jtt.lang.Class_isInstance06.test(2)) {
16639 fail(runString);
16640 return;
16641 }
16642 // (3) == true
16643 runString = "(3)";
16644 if (true != jtt.lang.Class_isInstance06.test(3)) {
16645 fail(runString);
16646 return;
16647 }
16648 // (4) == false
16649 runString = "(4)";
16650 if (false != jtt.lang.Class_isInstance06.test(4)) {
16651 fail(runString);
16652 return;
16653 }
16654 } catch (Throwable t) {
16655 fail(runString, t);
16656 return;
16657 }
16658 pass();
16659 }
16660
16661 static void jtt_lang_Class_isInterface01() {
16662 begin("jtt.lang.Class_isInterface01");
16663 String runString = null;
16664 try {
16665 // (0) == false
16666 runString = "(0)";
16667 if (false != jtt.lang.Class_isInterface01.test(0)) {
16668 fail(runString);
16669 return;
16670 }
16671 // (1) == false
16672 runString = "(1)";
16673 if (false != jtt.lang.Class_isInterface01.test(1)) {
16674 fail(runString);
16675 return;
16676 }
16677 // (2) == false
16678 runString = "(2)";
16679 if (false != jtt.lang.Class_isInterface01.test(2)) {
16680 fail(runString);
16681 return;
16682 }
16683 // (3) == false
16684 runString = "(3)";
16685 if (false != jtt.lang.Class_isInterface01.test(3)) {
16686 fail(runString);
16687 return;
16688 }
16689 // (4) == false
16690 runString = "(4)";
16691 if (false != jtt.lang.Class_isInterface01.test(4)) {
16692 fail(runString);
16693 return;
16694 }
16695 // (5) == true
16696 runString = "(5)";
16697 if (true != jtt.lang.Class_isInterface01.test(5)) {
16698 fail(runString);
16699 return;
16700 }
16701 // (6) == true
16702 runString = "(6)";
16703 if (true != jtt.lang.Class_isInterface01.test(6)) {
16704 fail(runString);
16705 return;
16706 }
16707 // (7) == false
16708 runString = "(7)";
16709 if (false != jtt.lang.Class_isInterface01.test(7)) {
16710 fail(runString);
16711 return;
16712 }
16713 // (8) == false
16714 runString = "(8)";
16715 if (false != jtt.lang.Class_isInterface01.test(8)) {
16716 fail(runString);
16717 return;
16718 }
16719 } catch (Throwable t) {
16720 fail(runString, t);
16721 return;
16722 }
16723 pass();
16724 }
16725
16726 static void jtt_lang_Class_isPrimitive01() {
16727 begin("jtt.lang.Class_isPrimitive01");
16728 String runString = null;
16729 try {
16730 // (0) == true
16731 runString = "(0)";
16732 if (true != jtt.lang.Class_isPrimitive01.test(0)) {
16733 fail(runString);
16734 return;
16735 }
16736 // (1) == false
16737 runString = "(1)";
16738 if (false != jtt.lang.Class_isPrimitive01.test(1)) {
16739 fail(runString);
16740 return;
16741 }
16742 // (2) == false
16743 runString = "(2)";
16744 if (false != jtt.lang.Class_isPrimitive01.test(2)) {
16745 fail(runString);
16746 return;
16747 }
16748 // (3) == false
16749 runString = "(3)";
16750 if (false != jtt.lang.Class_isPrimitive01.test(3)) {
16751 fail(runString);
16752 return;
16753 }
16754 // (4) == false
16755 runString = "(4)";
16756 if (false != jtt.lang.Class_isPrimitive01.test(4)) {
16757 fail(runString);
16758 return;
16759 }
16760 // (5) == false
16761 runString = "(5)";
16762 if (false != jtt.lang.Class_isPrimitive01.test(5)) {
16763 fail(runString);
16764 return;
16765 }
16766 // (6) == false
16767 runString = "(6)";
16768 if (false != jtt.lang.Class_isPrimitive01.test(6)) {
16769 fail(runString);
16770 return;
16771 }
16772 // (7) == true
16773 runString = "(7)";
16774 if (true != jtt.lang.Class_isPrimitive01.test(7)) {
16775 fail(runString);
16776 return;
16777 }
16778 // (8) == false
16779 runString = "(8)";
16780 if (false != jtt.lang.Class_isPrimitive01.test(8)) {
16781 fail(runString);
16782 return;
16783 }
16784 } catch (Throwable t) {
16785 fail(runString, t);
16786 return;
16787 }
16788 pass();
16789 }
16790
16791 static void jtt_lang_Double_toString() {
16792 begin("jtt.lang.Double_toString");
16793 String runString = null;
16794 try {
16795 // (0) == "9.834050399508132E-4"
16796 runString = "(0)";
16797 if (!"9.834050399508132E-4"
16798 .equals(jtt.lang.Double_toString.test(0))) {
16799 fail(runString);
16800 return;
16801 }
16802 } catch (Throwable t) {
16803 fail(runString, t);
16804 return;
16805 }
16806 pass();
16807 }
16808
16809 static void jtt_lang_Float_01() {
16810 begin("jtt.lang.Float_01");
16811 String runString = null;
16812 try {
16813 // (1.0) == false
16814 runString = "(1.0)";
16815 if (false != jtt.lang.Float_01.test(1.0f)) {
16816 fail(runString);
16817 return;
16818 }
16819 // (2.0) == false
16820 runString = "(2.0)";
16821 if (false != jtt.lang.Float_01.test(2.0f)) {
16822 fail(runString);
16823 return;
16824 }
16825 // (0.5) == false
16826 runString = "(0.5)";
16827 if (false != jtt.lang.Float_01.test(0.5f)) {
16828 fail(runString);
16829 return;
16830 }
16831 // (java.lang.Float.NaN) == true
16832 runString = "(java.lang.Float.NaN)";
16833 if (true != jtt.lang.Float_01.test(java.lang.Float.NaN)) {
16834 fail(runString);
16835 return;
16836 }
16837 } catch (Throwable t) {
16838 fail(runString, t);
16839 return;
16840 }
16841 pass();
16842 }
16843
16844 static void jtt_lang_Float_02() {
16845 begin("jtt.lang.Float_02");
16846 String runString = null;
16847 try {
16848 // (1.0) == false
16849 runString = "(1.0)";
16850 if (false != jtt.lang.Float_02.test(1.0f)) {
16851 fail(runString);
16852 return;
16853 }
16854 // (2.0) == true
16855 runString = "(2.0)";
16856 if (true != jtt.lang.Float_02.test(2.0f)) {
16857 fail(runString);
16858 return;
16859 }
16860 // (0.5) == true
16861 runString = "(0.5)";
16862 if (true != jtt.lang.Float_02.test(0.5f)) {
16863 fail(runString);
16864 return;
16865 }
16866 // (java.lang.Float.NaN) == true
16867 runString = "(java.lang.Float.NaN)";
16868 if (true != jtt.lang.Float_02.test(java.lang.Float.NaN)) {
16869 fail(runString);
16870 return;
16871 }
16872 } catch (Throwable t) {
16873 fail(runString, t);
16874 return;
16875 }
16876 pass();
16877 }
16878
16879 static void jtt_lang_Int_greater01() {
16880 begin("jtt.lang.Int_greater01");
16881 String runString = null;
16882 try {
16883 // (-2147483648) == false
16884 runString = "(-2147483648)";
16885 if (false != jtt.lang.Int_greater01.test(-2147483648)) {
16886 fail(runString);
16887 return;
16888 }
16889 // (-2) == false
16890 runString = "(-2)";
16891 if (false != jtt.lang.Int_greater01.test(-2)) {
16892 fail(runString);
16893 return;
16894 }
16895 // (-1) == false
16896 runString = "(-1)";
16897 if (false != jtt.lang.Int_greater01.test(-1)) {
16898 fail(runString);
16899 return;
16900 }
16901 // (0) == false
16902 runString = "(0)";
16903 if (false != jtt.lang.Int_greater01.test(0)) {
16904 fail(runString);
16905 return;
16906 }
16907 // (1) == true
16908 runString = "(1)";
16909 if (true != jtt.lang.Int_greater01.test(1)) {
16910 fail(runString);
16911 return;
16912 }
16913 // (2) == true
16914 runString = "(2)";
16915 if (true != jtt.lang.Int_greater01.test(2)) {
16916 fail(runString);
16917 return;
16918 }
16919 // (2147483647) == true
16920 runString = "(2147483647)";
16921 if (true != jtt.lang.Int_greater01.test(2147483647)) {
16922 fail(runString);
16923 return;
16924 }
16925 } catch (Throwable t) {
16926 fail(runString, t);
16927 return;
16928 }
16929 pass();
16930 }
16931
16932 static void jtt_lang_Int_greater02() {
16933 begin("jtt.lang.Int_greater02");
16934 String runString = null;
16935 try {
16936 // (-2147483648) == false
16937 runString = "(-2147483648)";
16938 if (false != jtt.lang.Int_greater02.test(-2147483648)) {
16939 fail(runString);
16940 return;
16941 }
16942 // (-2) == false
16943 runString = "(-2)";
16944 if (false != jtt.lang.Int_greater02.test(-2)) {
16945 fail(runString);
16946 return;
16947 }
16948 // (-1) == false
16949 runString = "(-1)";
16950 if (false != jtt.lang.Int_greater02.test(-1)) {
16951 fail(runString);
16952 return;
16953 }
16954 // (0) == false
16955 runString = "(0)";
16956 if (false != jtt.lang.Int_greater02.test(0)) {
16957 fail(runString);
16958 return;
16959 }
16960 // (1) == false
16961 runString = "(1)";
16962 if (false != jtt.lang.Int_greater02.test(1)) {
16963 fail(runString);
16964 return;
16965 }
16966 // (4) == false
16967 runString = "(4)";
16968 if (false != jtt.lang.Int_greater02.test(4)) {
16969 fail(runString);
16970 return;
16971 }
16972 // (5) == false
16973 runString = "(5)";
16974 if (false != jtt.lang.Int_greater02.test(5)) {
16975 fail(runString);
16976 return;
16977 }
16978 // (6) == true
16979 runString = "(6)";
16980 if (true != jtt.lang.Int_greater02.test(6)) {
16981 fail(runString);
16982 return;
16983 }
16984 // (2147483647) == true
16985 runString = "(2147483647)";
16986 if (true != jtt.lang.Int_greater02.test(2147483647)) {
16987 fail(runString);
16988 return;
16989 }
16990 } catch (Throwable t) {
16991 fail(runString, t);
16992 return;
16993 }
16994 pass();
16995 }
16996
16997 static void jtt_lang_Int_greater03() {
16998 begin("jtt.lang.Int_greater03");
16999 String runString = null;
17000 try {
17001 // (-2147483648) == false
17002 runString = "(-2147483648)";
17003 if (false != jtt.lang.Int_greater03.test(-2147483648)) {
17004 fail(runString);
17005 return;
17006 }
17007 // (-6) == false
17008 runString = "(-6)";
17009 if (false != jtt.lang.Int_greater03.test(-6)) {
17010 fail(runString);
17011 return;
17012 }
17013 // (-5) == false
17014 runString = "(-5)";
17015 if (false != jtt.lang.Int_greater03.test(-5)) {
17016 fail(runString);
17017 return;
17018 }
17019 // (-4) == true
17020 runString = "(-4)";
17021 if (true != jtt.lang.Int_greater03.test(-4)) {
17022 fail(runString);
17023 return;
17024 }
17025 // (-1) == true
17026 runString = "(-1)";
17027 if (true != jtt.lang.Int_greater03.test(-1)) {
17028 fail(runString);
17029 return;
17030 }
17031 // (0) == true
17032 runString = "(0)";
17033 if (true != jtt.lang.Int_greater03.test(0)) {
17034 fail(runString);
17035 return;
17036 }
17037 // (1) == true
17038 runString = "(1)";
17039 if (true != jtt.lang.Int_greater03.test(1)) {
17040 fail(runString);
17041 return;
17042 }
17043 // (2) == true
17044 runString = "(2)";
17045 if (true != jtt.lang.Int_greater03.test(2)) {
17046 fail(runString);
17047 return;
17048 }
17049 // (2147483647) == true
17050 runString = "(2147483647)";
17051 if (true != jtt.lang.Int_greater03.test(2147483647)) {
17052 fail(runString);
17053 return;
17054 }
17055 } catch (Throwable t) {
17056 fail(runString, t);
17057 return;
17058 }
17059 pass();
17060 }
17061
17062 static void jtt_lang_Int_greaterEqual01() {
17063 begin("jtt.lang.Int_greaterEqual01");
17064 String runString = null;
17065 try {
17066 // (-2147483648) == false
17067 runString = "(-2147483648)";
17068 if (false != jtt.lang.Int_greaterEqual01.test(-2147483648)) {
17069 fail(runString);
17070 return;
17071 }
17072 // (-2) == false
17073 runString = "(-2)";
17074 if (false != jtt.lang.Int_greaterEqual01.test(-2)) {
17075 fail(runString);
17076 return;
17077 }
17078 // (-1) == false
17079 runString = "(-1)";
17080 if (false != jtt.lang.Int_greaterEqual01.test(-1)) {
17081 fail(runString);
17082 return;
17083 }
17084 // (0) == true
17085 runString = "(0)";
17086 if (true != jtt.lang.Int_greaterEqual01.test(0)) {
17087 fail(runString);
17088 return;
17089 }
17090 // (1) == true
17091 runString = "(1)";
17092 if (true != jtt.lang.Int_greaterEqual01.test(1)) {
17093 fail(runString);
17094 return;
17095 }
17096 // (2) == true
17097 runString = "(2)";
17098 if (true != jtt.lang.Int_greaterEqual01.test(2)) {
17099 fail(runString);
17100 return;
17101 }
17102 // (2147483647) == true
17103 runString = "(2147483647)";
17104 if (true != jtt.lang.Int_greaterEqual01.test(2147483647)) {
17105 fail(runString);
17106 return;
17107 }
17108 } catch (Throwable t) {
17109 fail(runString, t);
17110 return;
17111 }
17112 pass();
17113 }
17114
17115 static void jtt_lang_Int_greaterEqual02() {
17116 begin("jtt.lang.Int_greaterEqual02");
17117 String runString = null;
17118 try {
17119 // (-2147483648) == false
17120 runString = "(-2147483648)";
17121 if (false != jtt.lang.Int_greaterEqual02.test(-2147483648)) {
17122 fail(runString);
17123 return;
17124 }
17125 // (-2) == false
17126 runString = "(-2)";
17127 if (false != jtt.lang.Int_greaterEqual02.test(-2)) {
17128 fail(runString);
17129 return;
17130 }
17131 // (-1) == false
17132 runString = "(-1)";
17133 if (false != jtt.lang.Int_greaterEqual02.test(-1)) {
17134 fail(runString);
17135 return;
17136 }
17137 // (0) == false
17138 runString = "(0)";
17139 if (false != jtt.lang.Int_greaterEqual02.test(0)) {
17140 fail(runString);
17141 return;
17142 }
17143 // (1) == false
17144 runString = "(1)";
17145 if (false != jtt.lang.Int_greaterEqual02.test(1)) {
17146 fail(runString);
17147 return;
17148 }
17149 // (4) == false
17150 runString = "(4)";
17151 if (false != jtt.lang.Int_greaterEqual02.test(4)) {
17152 fail(runString);
17153 return;
17154 }
17155 // (5) == true
17156 runString = "(5)";
17157 if (true != jtt.lang.Int_greaterEqual02.test(5)) {
17158 fail(runString);
17159 return;
17160 }
17161 // (6) == true
17162 runString = "(6)";
17163 if (true != jtt.lang.Int_greaterEqual02.test(6)) {
17164 fail(runString);
17165 return;
17166 }
17167 // (2147483647) == true
17168 runString = "(2147483647)";
17169 if (true != jtt.lang.Int_greaterEqual02.test(2147483647)) {
17170 fail(runString);
17171 return;
17172 }
17173 } catch (Throwable t) {
17174 fail(runString, t);
17175 return;
17176 }
17177 pass();
17178 }
17179
17180 static void jtt_lang_Int_greaterEqual03() {
17181 begin("jtt.lang.Int_greaterEqual03");
17182 String runString = null;
17183 try {
17184 // (-2147483648) == false
17185 runString = "(-2147483648)";
17186 if (false != jtt.lang.Int_greaterEqual03.test(-2147483648)) {
17187 fail(runString);
17188 return;
17189 }
17190 // (-6) == false
17191 runString = "(-6)";
17192 if (false != jtt.lang.Int_greaterEqual03.test(-6)) {
17193 fail(runString);
17194 return;
17195 }
17196 // (-5) == true
17197 runString = "(-5)";
17198 if (true != jtt.lang.Int_greaterEqual03.test(-5)) {
17199 fail(runString);
17200 return;
17201 }
17202 // (-4) == true
17203 runString = "(-4)";
17204 if (true != jtt.lang.Int_greaterEqual03.test(-4)) {
17205 fail(runString);
17206 return;
17207 }
17208 // (-1) == true
17209 runString = "(-1)";
17210 if (true != jtt.lang.Int_greaterEqual03.test(-1)) {
17211 fail(runString);
17212 return;
17213 }
17214 // (0) == true
17215 runString = "(0)";
17216 if (true != jtt.lang.Int_greaterEqual03.test(0)) {
17217 fail(runString);
17218 return;
17219 }
17220 // (1) == true
17221 runString = "(1)";
17222 if (true != jtt.lang.Int_greaterEqual03.test(1)) {
17223 fail(runString);
17224 return;
17225 }
17226 // (2) == true
17227 runString = "(2)";
17228 if (true != jtt.lang.Int_greaterEqual03.test(2)) {
17229 fail(runString);
17230 return;
17231 }
17232 // (2147483647) == true
17233 runString = "(2147483647)";
17234 if (true != jtt.lang.Int_greaterEqual03.test(2147483647)) {
17235 fail(runString);
17236 return;
17237 }
17238 } catch (Throwable t) {
17239 fail(runString, t);
17240 return;
17241 }
17242 pass();
17243 }
17244
17245 static void jtt_lang_Int_less01() {
17246 begin("jtt.lang.Int_less01");
17247 String runString = null;
17248 try {
17249 // (-2147483648) == true
17250 runString = "(-2147483648)";
17251 if (true != jtt.lang.Int_less01.test(-2147483648)) {
17252 fail(runString);
17253 return;
17254 }
17255 // (-2) == true
17256 runString = "(-2)";
17257 if (true != jtt.lang.Int_less01.test(-2)) {
17258 fail(runString);
17259 return;
17260 }
17261 // (-1) == true
17262 runString = "(-1)";
17263 if (true != jtt.lang.Int_less01.test(-1)) {
17264 fail(runString);
17265 return;
17266 }
17267 // (0) == false
17268 runString = "(0)";
17269 if (false != jtt.lang.Int_less01.test(0)) {
17270 fail(runString);
17271 return;
17272 }
17273 // (1) == false
17274 runString = "(1)";
17275 if (false != jtt.lang.Int_less01.test(1)) {
17276 fail(runString);
17277 return;
17278 }
17279 // (2) == false
17280 runString = "(2)";
17281 if (false != jtt.lang.Int_less01.test(2)) {
17282 fail(runString);
17283 return;
17284 }
17285 // (2147483647) == false
17286 runString = "(2147483647)";
17287 if (false != jtt.lang.Int_less01.test(2147483647)) {
17288 fail(runString);
17289 return;
17290 }
17291 } catch (Throwable t) {
17292 fail(runString, t);
17293 return;
17294 }
17295 pass();
17296 }
17297
17298 static void jtt_lang_Int_less02() {
17299 begin("jtt.lang.Int_less02");
17300 String runString = null;
17301 try {
17302 // (-2147483648) == true
17303 runString = "(-2147483648)";
17304 if (true != jtt.lang.Int_less02.test(-2147483648)) {
17305 fail(runString);
17306 return;
17307 }
17308 // (-2) == true
17309 runString = "(-2)";
17310 if (true != jtt.lang.Int_less02.test(-2)) {
17311 fail(runString);
17312 return;
17313 }
17314 // (-1) == true
17315 runString = "(-1)";
17316 if (true != jtt.lang.Int_less02.test(-1)) {
17317 fail(runString);
17318 return;
17319 }
17320 // (0) == true
17321 runString = "(0)";
17322 if (true != jtt.lang.Int_less02.test(0)) {
17323 fail(runString);
17324 return;
17325 }
17326 // (4) == true
17327 runString = "(4)";
17328 if (true != jtt.lang.Int_less02.test(4)) {
17329 fail(runString);
17330 return;
17331 }
17332 // (5) == false
17333 runString = "(5)";
17334 if (false != jtt.lang.Int_less02.test(5)) {
17335 fail(runString);
17336 return;
17337 }
17338 // (6) == false
17339 runString = "(6)";
17340 if (false != jtt.lang.Int_less02.test(6)) {
17341 fail(runString);
17342 return;
17343 }
17344 // (2147483647) == false
17345 runString = "(2147483647)";
17346 if (false != jtt.lang.Int_less02.test(2147483647)) {
17347 fail(runString);
17348 return;
17349 }
17350 } catch (Throwable t) {
17351 fail(runString, t);
17352 return;
17353 }
17354 pass();
17355 }
17356
17357 static void jtt_lang_Int_less03() {
17358 begin("jtt.lang.Int_less03");
17359 String runString = null;
17360 try {
17361 // (-2147483648) == true
17362 runString = "(-2147483648)";
17363 if (true != jtt.lang.Int_less03.test(-2147483648)) {
17364 fail(runString);
17365 return;
17366 }
17367 // (-6) == true
17368 runString = "(-6)";
17369 if (true != jtt.lang.Int_less03.test(-6)) {
17370 fail(runString);
17371 return;
17372 }
17373 // (-5) == false
17374 runString = "(-5)";
17375 if (false != jtt.lang.Int_less03.test(-5)) {
17376 fail(runString);
17377 return;
17378 }
17379 // (-4) == false
17380 runString = "(-4)";
17381 if (false != jtt.lang.Int_less03.test(-4)) {
17382 fail(runString);
17383 return;
17384 }
17385 // (-1) == false
17386 runString = "(-1)";
17387 if (false != jtt.lang.Int_less03.test(-1)) {
17388 fail(runString);
17389 return;
17390 }
17391 // (0) == false
17392 runString = "(0)";
17393 if (false != jtt.lang.Int_less03.test(0)) {
17394 fail(runString);
17395 return;
17396 }
17397 // (1) == false
17398 runString = "(1)";
17399 if (false != jtt.lang.Int_less03.test(1)) {
17400 fail(runString);
17401 return;
17402 }
17403 // (2) == false
17404 runString = "(2)";
17405 if (false != jtt.lang.Int_less03.test(2)) {
17406 fail(runString);
17407 return;
17408 }
17409 // (2147483647) == false
17410 runString = "(2147483647)";
17411 if (false != jtt.lang.Int_less03.test(2147483647)) {
17412 fail(runString);
17413 return;
17414 }
17415 } catch (Throwable t) {
17416 fail(runString, t);
17417 return;
17418 }
17419 pass();
17420 }
17421
17422 static void jtt_lang_Int_lessEqual01() {
17423 begin("jtt.lang.Int_lessEqual01");
17424 String runString = null;
17425 try {
17426 // (-2147483648) == true
17427 runString = "(-2147483648)";
17428 if (true != jtt.lang.Int_lessEqual01.test(-2147483648)) {
17429 fail(runString);
17430 return;
17431 }
17432 // (-2) == true
17433 runString = "(-2)";
17434 if (true != jtt.lang.Int_lessEqual01.test(-2)) {
17435 fail(runString);
17436 return;
17437 }
17438 // (-1) == true
17439 runString = "(-1)";
17440 if (true != jtt.lang.Int_lessEqual01.test(-1)) {
17441 fail(runString);
17442 return;
17443 }
17444 // (0) == true
17445 runString = "(0)";
17446 if (true != jtt.lang.Int_lessEqual01.test(0)) {
17447 fail(runString);
17448 return;
17449 }
17450 // (1) == false
17451 runString = "(1)";
17452 if (false != jtt.lang.Int_lessEqual01.test(1)) {
17453 fail(runString);
17454 return;
17455 }
17456 // (2) == false
17457 runString = "(2)";
17458 if (false != jtt.lang.Int_lessEqual01.test(2)) {
17459 fail(runString);
17460 return;
17461 }
17462 // (2147483647) == false
17463 runString = "(2147483647)";
17464 if (false != jtt.lang.Int_lessEqual01.test(2147483647)) {
17465 fail(runString);
17466 return;
17467 }
17468 } catch (Throwable t) {
17469 fail(runString, t);
17470 return;
17471 }
17472 pass();
17473 }
17474
17475 static void jtt_lang_Int_lessEqual02() {
17476 begin("jtt.lang.Int_lessEqual02");
17477 String runString = null;
17478 try {
17479 // (-2147483648) == true
17480 runString = "(-2147483648)";
17481 if (true != jtt.lang.Int_lessEqual02.test(-2147483648)) {
17482 fail(runString);
17483 return;
17484 }
17485 // (-2) == true
17486 runString = "(-2)";
17487 if (true != jtt.lang.Int_lessEqual02.test(-2)) {
17488 fail(runString);
17489 return;
17490 }
17491 // (-1) == true
17492 runString = "(-1)";
17493 if (true != jtt.lang.Int_lessEqual02.test(-1)) {
17494 fail(runString);
17495 return;
17496 }
17497 // (0) == true
17498 runString = "(0)";
17499 if (true != jtt.lang.Int_lessEqual02.test(0)) {
17500 fail(runString);
17501 return;
17502 }
17503 // (4) == true
17504 runString = "(4)";
17505 if (true != jtt.lang.Int_lessEqual02.test(4)) {
17506 fail(runString);
17507 return;
17508 }
17509 // (5) == true
17510 runString = "(5)";
17511 if (true != jtt.lang.Int_lessEqual02.test(5)) {
17512 fail(runString);
17513 return;
17514 }
17515 // (6) == false
17516 runString = "(6)";
17517 if (false != jtt.lang.Int_lessEqual02.test(6)) {
17518 fail(runString);
17519 return;
17520 }
17521 // (2147483647) == false
17522 runString = "(2147483647)";
17523 if (false != jtt.lang.Int_lessEqual02.test(2147483647)) {
17524 fail(runString);
17525 return;
17526 }
17527 } catch (Throwable t) {
17528 fail(runString, t);
17529 return;
17530 }
17531 pass();
17532 }
17533
17534 static void jtt_lang_Int_lessEqual03() {
17535 begin("jtt.lang.Int_lessEqual03");
17536 String runString = null;
17537 try {
17538 // (-2147483648) == true
17539 runString = "(-2147483648)";
17540 if (true != jtt.lang.Int_lessEqual03.test(-2147483648)) {
17541 fail(runString);
17542 return;
17543 }
17544 // (-6) == true
17545 runString = "(-6)";
17546 if (true != jtt.lang.Int_lessEqual03.test(-6)) {
17547 fail(runString);
17548 return;
17549 }
17550 // (-5) == true
17551 runString = "(-5)";
17552 if (true != jtt.lang.Int_lessEqual03.test(-5)) {
17553 fail(runString);
17554 return;
17555 }
17556 // (-4) == false
17557 runString = "(-4)";
17558 if (false != jtt.lang.Int_lessEqual03.test(-4)) {
17559 fail(runString);
17560 return;
17561 }
17562 // (-1) == false
17563 runString = "(-1)";
17564 if (false != jtt.lang.Int_lessEqual03.test(-1)) {
17565 fail(runString);
17566 return;
17567 }
17568 // (0) == false
17569 runString = "(0)";
17570 if (false != jtt.lang.Int_lessEqual03.test(0)) {
17571 fail(runString);
17572 return;
17573 }
17574 // (1) == false
17575 runString = "(1)";
17576 if (false != jtt.lang.Int_lessEqual03.test(1)) {
17577 fail(runString);
17578 return;
17579 }
17580 // (2) == false
17581 runString = "(2)";
17582 if (false != jtt.lang.Int_lessEqual03.test(2)) {
17583 fail(runString);
17584 return;
17585 }
17586 // (2147483647) == false
17587 runString = "(2147483647)";
17588 if (false != jtt.lang.Int_lessEqual03.test(2147483647)) {
17589 fail(runString);
17590 return;
17591 }
17592 } catch (Throwable t) {
17593 fail(runString, t);
17594 return;
17595 }
17596 pass();
17597 }
17598
17599 static void jtt_lang_JDK_ClassLoaders01() {
17600 begin("jtt.lang.JDK_ClassLoaders01");
17601 String runString = null;
17602 try {
17603 // (0) == true
17604 runString = "(0)";
17605 if (true != jtt.lang.JDK_ClassLoaders01.test(0)) {
17606 fail(runString);
17607 return;
17608 }
17609 // (1) == true
17610 runString = "(1)";
17611 if (true != jtt.lang.JDK_ClassLoaders01.test(1)) {
17612 fail(runString);
17613 return;
17614 }
17615 // (2) == true
17616 runString = "(2)";
17617 if (true != jtt.lang.JDK_ClassLoaders01.test(2)) {
17618 fail(runString);
17619 return;
17620 }
17621 // (3) == true
17622 runString = "(3)";
17623 if (true != jtt.lang.JDK_ClassLoaders01.test(3)) {
17624 fail(runString);
17625 return;
17626 }
17627 // (4) == true
17628 runString = "(4)";
17629 if (true != jtt.lang.JDK_ClassLoaders01.test(4)) {
17630 fail(runString);
17631 return;
17632 }
17633 // (5) == true
17634 runString = "(5)";
17635 if (true != jtt.lang.JDK_ClassLoaders01.test(5)) {
17636 fail(runString);
17637 return;
17638 }
17639 // (6) == false
17640 runString = "(6)";
17641 if (false != jtt.lang.JDK_ClassLoaders01.test(6)) {
17642 fail(runString);
17643 return;
17644 }
17645 } catch (Throwable t) {
17646 fail(runString, t);
17647 return;
17648 }
17649 pass();
17650 }
17651
17652 static void jtt_lang_JDK_ClassLoaders02() {
17653 begin("jtt.lang.JDK_ClassLoaders02");
17654 String runString = null;
17655 try {
17656 // (0) == true
17657 runString = "(0)";
17658 if (true != jtt.lang.JDK_ClassLoaders02.test(0)) {
17659 fail(runString);
17660 return;
17661 }
17662 } catch (Throwable t) {
17663 fail(runString, t);
17664 return;
17665 }
17666 pass();
17667 }
17668
17669 static void jtt_lang_Long_greater01() {
17670 begin("jtt.lang.Long_greater01");
17671 String runString = null;
17672 try {
17673 // (-9223372036854775808) == false
17674 runString = "(-9223372036854775808)";
17675 if (false != jtt.lang.Long_greater01.test(-9223372036854775808L)) {
17676 fail(runString);
17677 return;
17678 }
17679 // (-2) == false
17680 runString = "(-2)";
17681 if (false != jtt.lang.Long_greater01.test(-2L)) {
17682 fail(runString);
17683 return;
17684 }
17685 // (-1) == false
17686 runString = "(-1)";
17687 if (false != jtt.lang.Long_greater01.test(-1L)) {
17688 fail(runString);
17689 return;
17690 }
17691 // (0) == false
17692 runString = "(0)";
17693 if (false != jtt.lang.Long_greater01.test(0L)) {
17694 fail(runString);
17695 return;
17696 }
17697 // (1) == true
17698 runString = "(1)";
17699 if (true != jtt.lang.Long_greater01.test(1L)) {
17700 fail(runString);
17701 return;
17702 }
17703 // (2) == true
17704 runString = "(2)";
17705 if (true != jtt.lang.Long_greater01.test(2L)) {
17706 fail(runString);
17707 return;
17708 }
17709 // (9223372036854775807) == true
17710 runString = "(9223372036854775807)";
17711 if (true != jtt.lang.Long_greater01.test(9223372036854775807L)) {
17712 fail(runString);
17713 return;
17714 }
17715 } catch (Throwable t) {
17716 fail(runString, t);
17717 return;
17718 }
17719 pass();
17720 }
17721
17722 static void jtt_lang_Long_greater02() {
17723 begin("jtt.lang.Long_greater02");
17724 String runString = null;
17725 try {
17726 // (-9223372036854775808) == false
17727 runString = "(-9223372036854775808)";
17728 if (false != jtt.lang.Long_greater02.test(-9223372036854775808L)) {
17729 fail(runString);
17730 return;
17731 }
17732 // (-2) == false
17733 runString = "(-2)";
17734 if (false != jtt.lang.Long_greater02.test(-2L)) {
17735 fail(runString);
17736 return;
17737 }
17738 // (-1) == false
17739 runString = "(-1)";
17740 if (false != jtt.lang.Long_greater02.test(-1L)) {
17741 fail(runString);
17742 return;
17743 }
17744 // (0) == false
17745 runString = "(0)";
17746 if (false != jtt.lang.Long_greater02.test(0L)) {
17747 fail(runString);
17748 return;
17749 }
17750 // (1) == false
17751 runString = "(1)";
17752 if (false != jtt.lang.Long_greater02.test(1L)) {
17753 fail(runString);
17754 return;
17755 }
17756 // (4) == false
17757 runString = "(4)";
17758 if (false != jtt.lang.Long_greater02.test(4L)) {
17759 fail(runString);
17760 return;
17761 }
17762 // (5) == false
17763 runString = "(5)";
17764 if (false != jtt.lang.Long_greater02.test(5L)) {
17765 fail(runString);
17766 return;
17767 }
17768 // (6) == true
17769 runString = "(6)";
17770 if (true != jtt.lang.Long_greater02.test(6L)) {
17771 fail(runString);
17772 return;
17773 }
17774 // (9223372036854775807) == true
17775 runString = "(9223372036854775807)";
17776 if (true != jtt.lang.Long_greater02.test(9223372036854775807L)) {
17777 fail(runString);
17778 return;
17779 }
17780 } catch (Throwable t) {
17781 fail(runString, t);
17782 return;
17783 }
17784 pass();
17785 }
17786
17787 static void jtt_lang_Long_greater03() {
17788 begin("jtt.lang.Long_greater03");
17789 String runString = null;
17790 try {
17791 // (-9223372036854775808) == false
17792 runString = "(-9223372036854775808)";
17793 if (false != jtt.lang.Long_greater03.test(-9223372036854775808L)) {
17794 fail(runString);
17795 return;
17796 }
17797 // (-6) == false
17798 runString = "(-6)";
17799 if (false != jtt.lang.Long_greater03.test(-6L)) {
17800 fail(runString);
17801 return;
17802 }
17803 // (-5) == false
17804 runString = "(-5)";
17805 if (false != jtt.lang.Long_greater03.test(-5L)) {
17806 fail(runString);
17807 return;
17808 }
17809 // (-4) == true
17810 runString = "(-4)";
17811 if (true != jtt.lang.Long_greater03.test(-4L)) {
17812 fail(runString);
17813 return;
17814 }
17815 // (-1) == true
17816 runString = "(-1)";
17817 if (true != jtt.lang.Long_greater03.test(-1L)) {
17818 fail(runString);
17819 return;
17820 }
17821 // (0) == true
17822 runString = "(0)";
17823 if (true != jtt.lang.Long_greater03.test(0L)) {
17824 fail(runString);
17825 return;
17826 }
17827 // (1) == true
17828 runString = "(1)";
17829 if (true != jtt.lang.Long_greater03.test(1L)) {
17830 fail(runString);
17831 return;
17832 }
17833 // (2) == true
17834 runString = "(2)";
17835 if (true != jtt.lang.Long_greater03.test(2L)) {
17836 fail(runString);
17837 return;
17838 }
17839 // (9223372036854775807) == true
17840 runString = "(9223372036854775807)";
17841 if (true != jtt.lang.Long_greater03.test(9223372036854775807L)) {
17842 fail(runString);
17843 return;
17844 }
17845 } catch (Throwable t) {
17846 fail(runString, t);
17847 return;
17848 }
17849 pass();
17850 }
17851
17852 static void jtt_lang_Long_greaterEqual01() {
17853 begin("jtt.lang.Long_greaterEqual01");
17854 String runString = null;
17855 try {
17856 // (-9223372036854775808) == false
17857 runString = "(-9223372036854775808)";
17858 if (false != jtt.lang.Long_greaterEqual01
17859 .test(-9223372036854775808L)) {
17860 fail(runString);
17861 return;
17862 }
17863 // (-2) == false
17864 runString = "(-2)";
17865 if (false != jtt.lang.Long_greaterEqual01.test(-2L)) {
17866 fail(runString);
17867 return;
17868 }
17869 // (-1) == false
17870 runString = "(-1)";
17871 if (false != jtt.lang.Long_greaterEqual01.test(-1L)) {
17872 fail(runString);
17873 return;
17874 }
17875 // (0) == true
17876 runString = "(0)";
17877 if (true != jtt.lang.Long_greaterEqual01.test(0L)) {
17878 fail(runString);
17879 return;
17880 }
17881 // (1) == true
17882 runString = "(1)";
17883 if (true != jtt.lang.Long_greaterEqual01.test(1L)) {
17884 fail(runString);
17885 return;
17886 }
17887 // (2) == true
17888 runString = "(2)";
17889 if (true != jtt.lang.Long_greaterEqual01.test(2L)) {
17890 fail(runString);
17891 return;
17892 }
17893 // (9223372036854775807) == true
17894 runString = "(9223372036854775807)";
17895 if (true != jtt.lang.Long_greaterEqual01.test(9223372036854775807L)) {
17896 fail(runString);
17897 return;
17898 }
17899 } catch (Throwable t) {
17900 fail(runString, t);
17901 return;
17902 }
17903 pass();
17904 }
17905
17906 static void jtt_lang_Long_greaterEqual02() {
17907 begin("jtt.lang.Long_greaterEqual02");
17908 String runString = null;
17909 try {
17910 // (-9223372036854775808) == false
17911 runString = "(-9223372036854775808)";
17912 if (false != jtt.lang.Long_greaterEqual02
17913 .test(-9223372036854775808L)) {
17914 fail(runString);
17915 return;
17916 }
17917 // (-2) == false
17918 runString = "(-2)";
17919 if (false != jtt.lang.Long_greaterEqual02.test(-2L)) {
17920 fail(runString);
17921 return;
17922 }
17923 // (-1) == false
17924 runString = "(-1)";
17925 if (false != jtt.lang.Long_greaterEqual02.test(-1L)) {
17926 fail(runString);
17927 return;
17928 }
17929 // (0) == false
17930 runString = "(0)";
17931 if (false != jtt.lang.Long_greaterEqual02.test(0L)) {
17932 fail(runString);
17933 return;
17934 }
17935 // (1) == false
17936 runString = "(1)";
17937 if (false != jtt.lang.Long_greaterEqual02.test(1L)) {
17938 fail(runString);
17939 return;
17940 }
17941 // (4) == false
17942 runString = "(4)";
17943 if (false != jtt.lang.Long_greaterEqual02.test(4L)) {
17944 fail(runString);
17945 return;
17946 }
17947 // (5) == true
17948 runString = "(5)";
17949 if (true != jtt.lang.Long_greaterEqual02.test(5L)) {
17950 fail(runString);
17951 return;
17952 }
17953 // (6) == true
17954 runString = "(6)";
17955 if (true != jtt.lang.Long_greaterEqual02.test(6L)) {
17956 fail(runString);
17957 return;
17958 }
17959 // (9223372036854775807) == true
17960 runString = "(9223372036854775807)";
17961 if (true != jtt.lang.Long_greaterEqual02.test(9223372036854775807L)) {
17962 fail(runString);
17963 return;
17964 }
17965 } catch (Throwable t) {
17966 fail(runString, t);
17967 return;
17968 }
17969 pass();
17970 }
17971
17972 static void jtt_lang_Long_greaterEqual03() {
17973 begin("jtt.lang.Long_greaterEqual03");
17974 String runString = null;
17975 try {
17976 // (-9223372036854775808) == false
17977 runString = "(-9223372036854775808)";
17978 if (false != jtt.lang.Long_greaterEqual03
17979 .test(-9223372036854775808L)) {
17980 fail(runString);
17981 return;
17982 }
17983 // (-6) == false
17984 runString = "(-6)";
17985 if (false != jtt.lang.Long_greaterEqual03.test(-6L)) {
17986 fail(runString);
17987 return;
17988 }
17989 // (-5) == true
17990 runString = "(-5)";
17991 if (true != jtt.lang.Long_greaterEqual03.test(-5L)) {
17992 fail(runString);
17993 return;
17994 }
17995 // (-4) == true
17996 runString = "(-4)";
17997 if (true != jtt.lang.Long_greaterEqual03.test(-4L)) {
17998 fail(runString);
17999 return;
18000 }
18001 // (-1) == true
18002 runString = "(-1)";
18003 if (true != jtt.lang.Long_greaterEqual03.test(-1L)) {
18004 fail(runString);
18005 return;
18006 }
18007 // (0) == true
18008 runString = "(0)";
18009 if (true != jtt.lang.Long_greaterEqual03.test(0L)) {
18010 fail(runString);
18011 return;
18012 }
18013 // (1) == true
18014 runString = "(1)";
18015 if (true != jtt.lang.Long_greaterEqual03.test(1L)) {
18016 fail(runString);
18017 return;
18018 }
18019 // (2) == true
18020 runString = "(2)";
18021 if (true != jtt.lang.Long_greaterEqual03.test(2L)) {
18022 fail(runString);
18023 return;
18024 }
18025 // (9223372036854775807) == true
18026 runString = "(9223372036854775807)";
18027 if (true != jtt.lang.Long_greaterEqual03.test(9223372036854775807L)) {
18028 fail(runString);
18029 return;
18030 }
18031 } catch (Throwable t) {
18032 fail(runString, t);
18033 return;
18034 }
18035 pass();
18036 }
18037
18038 static void jtt_lang_Long_less01() {
18039 begin("jtt.lang.Long_less01");
18040 String runString = null;
18041 try {
18042 // (-9223372036854775808) == true
18043 runString = "(-9223372036854775808)";
18044 if (true != jtt.lang.Long_less01.test(-9223372036854775808L)) {
18045 fail(runString);
18046 return;
18047 }
18048 // (-2) == true
18049 runString = "(-2)";
18050 if (true != jtt.lang.Long_less01.test(-2L)) {
18051 fail(runString);
18052 return;
18053 }
18054 // (-1) == true
18055 runString = "(-1)";
18056 if (true != jtt.lang.Long_less01.test(-1L)) {
18057 fail(runString);
18058 return;
18059 }
18060 // (0) == false
18061 runString = "(0)";
18062 if (false != jtt.lang.Long_less01.test(0L)) {
18063 fail(runString);
18064 return;
18065 }
18066 // (1) == false
18067 runString = "(1)";
18068 if (false != jtt.lang.Long_less01.test(1L)) {
18069 fail(runString);
18070 return;
18071 }
18072 // (2) == false
18073 runString = "(2)";
18074 if (false != jtt.lang.Long_less01.test(2L)) {
18075 fail(runString);
18076 return;
18077 }
18078 // (9223372036854775807) == false
18079 runString = "(9223372036854775807)";
18080 if (false != jtt.lang.Long_less01.test(9223372036854775807L)) {
18081 fail(runString);
18082 return;
18083 }
18084 } catch (Throwable t) {
18085 fail(runString, t);
18086 return;
18087 }
18088 pass();
18089 }
18090
18091 static void jtt_lang_Long_less02() {
18092 begin("jtt.lang.Long_less02");
18093 String runString = null;
18094 try {
18095 // (-9223372036854775808) == true
18096 runString = "(-9223372036854775808)";
18097 if (true != jtt.lang.Long_less02.test(-9223372036854775808L)) {
18098 fail(runString);
18099 return;
18100 }
18101 // (-2) == true
18102 runString = "(-2)";
18103 if (true != jtt.lang.Long_less02.test(-2L)) {
18104 fail(runString);
18105 return;
18106 }
18107 // (-1) == true
18108 runString = "(-1)";
18109 if (true != jtt.lang.Long_less02.test(-1L)) {
18110 fail(runString);
18111 return;
18112 }
18113 // (0) == true
18114 runString = "(0)";
18115 if (true != jtt.lang.Long_less02.test(0L)) {
18116 fail(runString);
18117 return;
18118 }
18119 // (4) == true
18120 runString = "(4)";
18121 if (true != jtt.lang.Long_less02.test(4L)) {
18122 fail(runString);
18123 return;
18124 }
18125 // (5) == false
18126 runString = "(5)";
18127 if (false != jtt.lang.Long_less02.test(5L)) {
18128 fail(runString);
18129 return;
18130 }
18131 // (6) == false
18132 runString = "(6)";
18133 if (false != jtt.lang.Long_less02.test(6L)) {
18134 fail(runString);
18135 return;
18136 }
18137 // (9223372036854775807) == false
18138 runString = "(9223372036854775807)";
18139 if (false != jtt.lang.Long_less02.test(9223372036854775807L)) {
18140 fail(runString);
18141 return;
18142 }
18143 } catch (Throwable t) {
18144 fail(runString, t);
18145 return;
18146 }
18147 pass();
18148 }
18149
18150 static void jtt_lang_Long_less03() {
18151 begin("jtt.lang.Long_less03");
18152 String runString = null;
18153 try {
18154 // (-9223372036854775808) == true
18155 runString = "(-9223372036854775808)";
18156 if (true != jtt.lang.Long_less03.test(-9223372036854775808L)) {
18157 fail(runString);
18158 return;
18159 }
18160 // (-6) == true
18161 runString = "(-6)";
18162 if (true != jtt.lang.Long_less03.test(-6L)) {
18163 fail(runString);
18164 return;
18165 }
18166 // (-5) == false
18167 runString = "(-5)";
18168 if (false != jtt.lang.Long_less03.test(-5L)) {
18169 fail(runString);
18170 return;
18171 }
18172 // (-4) == false
18173 runString = "(-4)";
18174 if (false != jtt.lang.Long_less03.test(-4L)) {
18175 fail(runString);
18176 return;
18177 }
18178 // (-1) == false
18179 runString = "(-1)";
18180 if (false != jtt.lang.Long_less03.test(-1L)) {
18181 fail(runString);
18182 return;
18183 }
18184 // (0) == false
18185 runString = "(0)";
18186 if (false != jtt.lang.Long_less03.test(0L)) {
18187 fail(runString);
18188 return;
18189 }
18190 // (1) == false
18191 runString = "(1)";
18192 if (false != jtt.lang.Long_less03.test(1L)) {
18193 fail(runString);
18194 return;
18195 }
18196 // (2) == false
18197 runString = "(2)";
18198 if (false != jtt.lang.Long_less03.test(2L)) {
18199 fail(runString);
18200 return;
18201 }
18202 // (9223372036854775807) == false
18203 runString = "(9223372036854775807)";
18204 if (false != jtt.lang.Long_less03.test(9223372036854775807L)) {
18205 fail(runString);
18206 return;
18207 }
18208 } catch (Throwable t) {
18209 fail(runString, t);
18210 return;
18211 }
18212 pass();
18213 }
18214
18215 static void jtt_lang_Long_lessEqual01() {
18216 begin("jtt.lang.Long_lessEqual01");
18217 String runString = null;
18218 try {
18219 // (-2) == true
18220 runString = "(-2)";
18221 if (true != jtt.lang.Long_lessEqual01.test(-2L)) {
18222 fail(runString);
18223 return;
18224 }
18225 // (-9223372036854775808) == true
18226 runString = "(-9223372036854775808)";
18227 if (true != jtt.lang.Long_lessEqual01.test(-9223372036854775808L)) {
18228 fail(runString);
18229 return;
18230 }
18231 // (-2) == true
18232 runString = "(-2)";
18233 if (true != jtt.lang.Long_lessEqual01.test(-2L)) {
18234 fail(runString);
18235 return;
18236 }
18237 // (-1) == true
18238 runString = "(-1)";
18239 if (true != jtt.lang.Long_lessEqual01.test(-1L)) {
18240 fail(runString);
18241 return;
18242 }
18243 // (0) == true
18244 runString = "(0)";
18245 if (true != jtt.lang.Long_lessEqual01.test(0L)) {
18246 fail(runString);
18247 return;
18248 }
18249 // (1) == false
18250 runString = "(1)";
18251 if (false != jtt.lang.Long_lessEqual01.test(1L)) {
18252 fail(runString);
18253 return;
18254 }
18255 // (2) == false
18256 runString = "(2)";
18257 if (false != jtt.lang.Long_lessEqual01.test(2L)) {
18258 fail(runString);
18259 return;
18260 }
18261 // (9223372036854775807) == false
18262 runString = "(9223372036854775807)";
18263 if (false != jtt.lang.Long_lessEqual01.test(9223372036854775807L)) {
18264 fail(runString);
18265 return;
18266 }
18267 } catch (Throwable t) {
18268 fail(runString, t);
18269 return;
18270 }
18271 pass();
18272 }
18273
18274 static void jtt_lang_Long_lessEqual02() {
18275 begin("jtt.lang.Long_lessEqual02");
18276 String runString = null;
18277 try {
18278 // (-9223372036854775808) == true
18279 runString = "(-9223372036854775808)";
18280 if (true != jtt.lang.Long_lessEqual02.test(-9223372036854775808L)) {
18281 fail(runString);
18282 return;
18283 }
18284 // (-2) == true
18285 runString = "(-2)";
18286 if (true != jtt.lang.Long_lessEqual02.test(-2L)) {
18287 fail(runString);
18288 return;
18289 }
18290 // (-1) == true
18291 runString = "(-1)";
18292 if (true != jtt.lang.Long_lessEqual02.test(-1L)) {
18293 fail(runString);
18294 return;
18295 }
18296 // (0) == true
18297 runString = "(0)";
18298 if (true != jtt.lang.Long_lessEqual02.test(0L)) {
18299 fail(runString);
18300 return;
18301 }
18302 // (4) == true
18303 runString = "(4)";
18304 if (true != jtt.lang.Long_lessEqual02.test(4L)) {
18305 fail(runString);
18306 return;
18307 }
18308 // (5) == true
18309 runString = "(5)";
18310 if (true != jtt.lang.Long_lessEqual02.test(5L)) {
18311 fail(runString);
18312 return;
18313 }
18314 // (6) == false
18315 runString = "(6)";
18316 if (false != jtt.lang.Long_lessEqual02.test(6L)) {
18317 fail(runString);
18318 return;
18319 }
18320 // (9223372036854775807) == false
18321 runString = "(9223372036854775807)";
18322 if (false != jtt.lang.Long_lessEqual02.test(9223372036854775807L)) {
18323 fail(runString);
18324 return;
18325 }
18326 } catch (Throwable t) {
18327 fail(runString, t);
18328 return;
18329 }
18330 pass();
18331 }
18332
18333 static void jtt_lang_Long_lessEqual03() {
18334 begin("jtt.lang.Long_lessEqual03");
18335 String runString = null;
18336 try {
18337 // (-9223372036854775808) == true
18338 runString = "(-9223372036854775808)";
18339 if (true != jtt.lang.Long_lessEqual03.test(-9223372036854775808L)) {
18340 fail(runString);
18341 return;
18342 }
18343 // (-6) == true
18344 runString = "(-6)";
18345 if (true != jtt.lang.Long_lessEqual03.test(-6L)) {
18346 fail(runString);
18347 return;
18348 }
18349 // (-5) == true
18350 runString = "(-5)";
18351 if (true != jtt.lang.Long_lessEqual03.test(-5L)) {
18352 fail(runString);
18353 return;
18354 }
18355 // (-4) == false
18356 runString = "(-4)";
18357 if (false != jtt.lang.Long_lessEqual03.test(-4L)) {
18358 fail(runString);
18359 return;
18360 }
18361 // (-1) == false
18362 runString = "(-1)";
18363 if (false != jtt.lang.Long_lessEqual03.test(-1L)) {
18364 fail(runString);
18365 return;
18366 }
18367 // (0) == false
18368 runString = "(0)";
18369 if (false != jtt.lang.Long_lessEqual03.test(0L)) {
18370 fail(runString);
18371 return;
18372 }
18373 // (1) == false
18374 runString = "(1)";
18375 if (false != jtt.lang.Long_lessEqual03.test(1L)) {
18376 fail(runString);
18377 return;
18378 }
18379 // (2) == false
18380 runString = "(2)";
18381 if (false != jtt.lang.Long_lessEqual03.test(2L)) {
18382 fail(runString);
18383 return;
18384 }
18385 // (9223372036854775807) == false
18386 runString = "(9223372036854775807)";
18387 if (false != jtt.lang.Long_lessEqual03.test(9223372036854775807L)) {
18388 fail(runString);
18389 return;
18390 }
18391 } catch (Throwable t) {
18392 fail(runString, t);
18393 return;
18394 }
18395 pass();
18396 }
18397
18398 static void jtt_lang_Long_reverseBytes01() {
18399 begin("jtt.lang.Long_reverseBytes01");
18400 String runString = null;
18401 try {
18402 // (1234605616436508424) == 610068790934446609
18403 runString = "(1234605616436508424)";
18404 if (610068790934446609L != jtt.lang.Long_reverseBytes01
18405 .test(1234605616436508424L)) {
18406 fail(runString);
18407 return;
18408 }
18409 } catch (Throwable t) {
18410 fail(runString, t);
18411 return;
18412 }
18413 pass();
18414 }
18415
18416 static void jtt_lang_Long_reverseBytes02() {
18417 begin("jtt.lang.Long_reverseBytes02");
18418 String runString = null;
18419 try {
18420 // (1234605616436508424) == 610068790934446609
18421 runString = "(1234605616436508424)";
18422 if (610068790934446609L != jtt.lang.Long_reverseBytes02
18423 .test(1234605616436508424L)) {
18424 fail(runString);
18425 return;
18426 }
18427 } catch (Throwable t) {
18428 fail(runString, t);
18429 return;
18430 }
18431 pass();
18432 }
18433
18434 static void jtt_lang_Math_pow() {
18435 begin("jtt.lang.Math_pow");
18436 String runString = null;
18437 try {
18438 // (2.0) == 4.0
18439 runString = "(2.0)";
18440 if (4.0 != jtt.lang.Math_pow.test(2.0)) {
18441 fail(runString);
18442 return;
18443 }
18444 // (3.1) == 8.574187700290345
18445 runString = "(3.1)";
18446 if (8.574187700290345 != jtt.lang.Math_pow.test(3.1)) {
18447 fail(runString);
18448 return;
18449 }
18450 } catch (Throwable t) {
18451 fail(runString, t);
18452 return;
18453 }
18454 pass();
18455 }
18456
18457 static void jtt_lang_Object_clone01() {
18458 begin("jtt.lang.Object_clone01");
18459 String runString = null;
18460 try {
18461 // (0) == !java.lang.CloneNotSupportedException
18462 try {
18463 runString = "(0)";
18464 jtt.lang.Object_clone01.test(0);
18465 fail(runString);
18466 return;
18467 } catch (Throwable e) {
18468 if (e.getClass() != java.lang.CloneNotSupportedException.class) {
18469 fail(runString, e);
18470 return;
18471 }
18472 }
18473 } catch (Throwable t) {
18474 fail(runString, t);
18475 return;
18476 }
18477 pass();
18478 }
18479
18480 static void jtt_lang_Object_clone02() {
18481 begin("jtt.lang.Object_clone02");
18482 String runString = null;
18483 try {
18484 // (0) == false
18485 runString = "(0)";
18486 if (false != jtt.lang.Object_clone02.test(0)) {
18487 fail(runString);
18488 return;
18489 }
18490 } catch (Throwable t) {
18491 fail(runString, t);
18492 return;
18493 }
18494 pass();
18495 }
18496
18497 static void jtt_lang_Object_equals01() {
18498 begin("jtt.lang.Object_equals01");
18499 String runString = null;
18500 try {
18501 // (0) == false
18502 runString = "(0)";
18503 if (false != jtt.lang.Object_equals01.test(0)) {
18504 fail(runString);
18505 return;
18506 }
18507 // (1) == false
18508 runString = "(1)";
18509 if (false != jtt.lang.Object_equals01.test(1)) {
18510 fail(runString);
18511 return;
18512 }
18513 // (2) == false
18514 runString = "(2)";
18515 if (false != jtt.lang.Object_equals01.test(2)) {
18516 fail(runString);
18517 return;
18518 }
18519 // (3) == true
18520 runString = "(3)";
18521 if (true != jtt.lang.Object_equals01.test(3)) {
18522 fail(runString);
18523 return;
18524 }
18525 // (4) == true
18526 runString = "(4)";
18527 if (true != jtt.lang.Object_equals01.test(4)) {
18528 fail(runString);
18529 return;
18530 }
18531 // (5) == false
18532 runString = "(5)";
18533 if (false != jtt.lang.Object_equals01.test(5)) {
18534 fail(runString);
18535 return;
18536 }
18537 // (6) == true
18538 runString = "(6)";
18539 if (true != jtt.lang.Object_equals01.test(6)) {
18540 fail(runString);
18541 return;
18542 }
18543 // (7) == false
18544 runString = "(7)";
18545 if (false != jtt.lang.Object_equals01.test(7)) {
18546 fail(runString);
18547 return;
18548 }
18549 // (8) == false
18550 runString = "(8)";
18551 if (false != jtt.lang.Object_equals01.test(8)) {
18552 fail(runString);
18553 return;
18554 }
18555 } catch (Throwable t) {
18556 fail(runString, t);
18557 return;
18558 }
18559 pass();
18560 }
18561
18562 static void jtt_lang_Object_getClass01() {
18563 begin("jtt.lang.Object_getClass01");
18564 String runString = null;
18565 try {
18566 // (0) == "class java.lang.Object"
18567 runString = "(0)";
18568 if (!"class java.lang.Object".equals(jtt.lang.Object_getClass01
18569 .test(0))) {
18570 fail(runString);
18571 return;
18572 }
18573 // (1) == "class java.lang.String"
18574 runString = "(1)";
18575 if (!"class java.lang.String".equals(jtt.lang.Object_getClass01
18576 .test(1))) {
18577 fail(runString);
18578 return;
18579 }
18580 // (2) == "class jtt.lang.Object_getClass01"
18581 runString = "(2)";
18582 if (!"class jtt.lang.Object_getClass01"
18583 .equals(jtt.lang.Object_getClass01.test(2))) {
18584 fail(runString);
18585 return;
18586 }
18587 } catch (Throwable t) {
18588 fail(runString, t);
18589 return;
18590 }
18591 pass();
18592 }
18593
18594 static void jtt_lang_Object_hashCode01() {
18595 begin("jtt.lang.Object_hashCode01");
18596 String runString = null;
18597 try {
18598 // (0) == true
18599 runString = "(0)";
18600 if (true != jtt.lang.Object_hashCode01.test(0)) {
18601 fail(runString);
18602 return;
18603 }
18604 } catch (Throwable t) {
18605 fail(runString, t);
18606 return;
18607 }
18608 pass();
18609 }
18610
18611 static void jtt_lang_Object_notify01() {
18612 begin("jtt.lang.Object_notify01");
18613 String runString = null;
18614 try {
18615 // (0) == !java.lang.IllegalMonitorStateException
18616 try {
18617 runString = "(0)";
18618 jtt.lang.Object_notify01.test(0);
18619 fail(runString);
18620 return;
18621 } catch (Throwable e) {
18622 if (e.getClass() != java.lang.IllegalMonitorStateException.class) {
18623 fail(runString, e);
18624 return;
18625 }
18626 }
18627 } catch (Throwable t) {
18628 fail(runString, t);
18629 return;
18630 }
18631 pass();
18632 }
18633
18634 static void jtt_lang_Object_notify02() {
18635 begin("jtt.lang.Object_notify02");
18636 String runString = null;
18637 try {
18638 // (0) == true
18639 runString = "(0)";
18640 if (true != jtt.lang.Object_notify02.test(0)) {
18641 fail(runString);
18642 return;
18643 }
18644 } catch (Throwable t) {
18645 fail(runString, t);
18646 return;
18647 }
18648 pass();
18649 }
18650
18651 static void jtt_lang_Object_notifyAll01() {
18652 begin("jtt.lang.Object_notifyAll01");
18653 String runString = null;
18654 try {
18655 // (0) == !java.lang.IllegalMonitorStateException
18656 try {
18657 runString = "(0)";
18658 jtt.lang.Object_notifyAll01.test(0);
18659 fail(runString);
18660 return;
18661 } catch (Throwable e) {
18662 if (e.getClass() != java.lang.IllegalMonitorStateException.class) {
18663 fail(runString, e);
18664 return;
18665 }
18666 }
18667 } catch (Throwable t) {
18668 fail(runString, t);
18669 return;
18670 }
18671 pass();
18672 }
18673
18674 static void jtt_lang_Object_notifyAll02() {
18675 begin("jtt.lang.Object_notifyAll02");
18676 String runString = null;
18677 try {
18678 // (0) == true
18679 runString = "(0)";
18680 if (true != jtt.lang.Object_notifyAll02.test(0)) {
18681 fail(runString);
18682 return;
18683 }
18684 } catch (Throwable t) {
18685 fail(runString, t);
18686 return;
18687 }
18688 pass();
18689 }
18690
18691 static void jtt_lang_Object_toString01() {
18692 begin("jtt.lang.Object_toString01");
18693 String runString = null;
18694 try {
18695 // (0) == true
18696 runString = "(0)";
18697 if (true != jtt.lang.Object_toString01.test(0)) {
18698 fail(runString);
18699 return;
18700 }
18701 // (1) == true
18702 runString = "(1)";
18703 if (true != jtt.lang.Object_toString01.test(1)) {
18704 fail(runString);
18705 return;
18706 }
18707 // (2) == false
18708 runString = "(2)";
18709 if (false != jtt.lang.Object_toString01.test(2)) {
18710 fail(runString);
18711 return;
18712 }
18713 } catch (Throwable t) {
18714 fail(runString, t);
18715 return;
18716 }
18717 pass();
18718 }
18719
18720 static void jtt_lang_Object_toString02() {
18721 begin("jtt.lang.Object_toString02");
18722 String runString = null;
18723 try {
18724 // (0) == "XYZ"
18725 runString = "(0)";
18726 if (!"XYZ".equals(jtt.lang.Object_toString02.test(0))) {
18727 fail(runString);
18728 return;
18729 }
18730 // (1) == "string"
18731 runString = "(1)";
18732 if (!"string".equals(jtt.lang.Object_toString02.test(1))) {
18733 fail(runString);
18734 return;
18735 }
18736 // (2) == "class java.lang.String"
18737 runString = "(2)";
18738 if (!"class java.lang.String".equals(jtt.lang.Object_toString02
18739 .test(2))) {
18740 fail(runString);
18741 return;
18742 }
18743 // (3) == !java.lang.NullPointerException
18744 try {
18745 runString = "(3)";
18746 jtt.lang.Object_toString02.test(3);
18747 fail(runString);
18748 return;
18749 } catch (Throwable e) {
18750 if (e.getClass() != java.lang.NullPointerException.class) {
18751 fail(runString, e);
18752 return;
18753 }
18754 }
18755 } catch (Throwable t) {
18756 fail(runString, t);
18757 return;
18758 }
18759 pass();
18760 }
18761
18762 static void jtt_lang_Object_wait01() {
18763 begin("jtt.lang.Object_wait01");
18764 String runString = null;
18765 try {
18766 // (0) == !java.lang.IllegalMonitorStateException
18767 try {
18768 runString = "(0)";
18769 jtt.lang.Object_wait01.test(0);
18770 fail(runString);
18771 return;
18772 } catch (Throwable e) {
18773 if (e.getClass() != java.lang.IllegalMonitorStateException.class) {
18774 fail(runString, e);
18775 return;
18776 }
18777 }
18778 } catch (Throwable t) {
18779 fail(runString, t);
18780 return;
18781 }
18782 pass();
18783 }
18784
18785 static void jtt_lang_Object_wait02() {
18786 begin("jtt.lang.Object_wait02");
18787 String runString = null;
18788 try {
18789 // (0) == true
18790 runString = "(0)";
18791 if (true != jtt.lang.Object_wait02.test(0)) {
18792 fail(runString);
18793 return;
18794 }
18795 } catch (Throwable t) {
18796 fail(runString, t);
18797 return;
18798 }
18799 pass();
18800 }
18801
18802 static void jtt_lang_Object_wait03() {
18803 begin("jtt.lang.Object_wait03");
18804 String runString = null;
18805 try {
18806 // (0) == true
18807 runString = "(0)";
18808 if (true != jtt.lang.Object_wait03.test(0)) {
18809 fail(runString);
18810 return;
18811 }
18812 } catch (Throwable t) {
18813 fail(runString, t);
18814 return;
18815 }
18816 pass();
18817 }
18818
18819 static void jtt_lang_ProcessEnvironment_init() {
18820 begin("jtt.lang.ProcessEnvironment_init");
18821 String runString = null;
18822 try {
18823 // (7) == 7
18824 runString = "(7)";
18825 if (7 != jtt.lang.ProcessEnvironment_init.test(7)) {
18826 fail(runString);
18827 return;
18828 }
18829 } catch (Throwable t) {
18830 fail(runString, t);
18831 return;
18832 }
18833 pass();
18834 }
18835
18836 static void jtt_lang_StringCoding_Scale() {
18837 begin("jtt.lang.StringCoding_Scale");
18838 String runString = null;
18839 try {
18840 // (2) == 2
18841 runString = "(2)";
18842 if (2 != jtt.lang.StringCoding_Scale.test(2)) {
18843 fail(runString);
18844 return;
18845 }
18846 // (1) == 1
18847 runString = "(1)";
18848 if (1 != jtt.lang.StringCoding_Scale.test(1)) {
18849 fail(runString);
18850 return;
18851 }
18852 // (0) == 0
18853 runString = "(0)";
18854 if (0 != jtt.lang.StringCoding_Scale.test(0)) {
18855 fail(runString);
18856 return;
18857 }
18858 } catch (Throwable t) {
18859 fail(runString, t);
18860 return;
18861 }
18862 pass();
18863 }
18864
18865 static void jtt_lang_String_intern01() {
18866 begin("jtt.lang.String_intern01");
18867 String runString = null;
18868 try {
18869 // (0) == true
18870 runString = "(0)";
18871 if (true != jtt.lang.String_intern01.test(0)) {
18872 fail(runString);
18873 return;
18874 }
18875 } catch (Throwable t) {
18876 fail(runString, t);
18877 return;
18878 }
18879 pass();
18880 }
18881
18882 static void jtt_lang_String_intern02() {
18883 begin("jtt.lang.String_intern02");
18884 String runString = null;
18885 try {
18886 // (0) == true
18887 runString = "(0)";
18888 if (true != jtt.lang.String_intern02.test(0)) {
18889 fail(runString);
18890 return;
18891 }
18892 // (1) == true
18893 runString = "(1)";
18894 if (true != jtt.lang.String_intern02.test(1)) {
18895 fail(runString);
18896 return;
18897 }
18898 // (2) == true
18899 runString = "(2)";
18900 if (true != jtt.lang.String_intern02.test(2)) {
18901 fail(runString);
18902 return;
18903 }
18904 } catch (Throwable t) {
18905 fail(runString, t);
18906 return;
18907 }
18908 pass();
18909 }
18910
18911 static void jtt_lang_String_intern03() {
18912 begin("jtt.lang.String_intern03");
18913 String runString = null;
18914 try {
18915 // (0) == true
18916 runString = "(0)";
18917 if (true != jtt.lang.String_intern03.test(0)) {
18918 fail(runString);
18919 return;
18920 }
18921 // (1) == true
18922 runString = "(1)";
18923 if (true != jtt.lang.String_intern03.test(1)) {
18924 fail(runString);
18925 return;
18926 }
18927 // (2) == true
18928 runString = "(2)";
18929 if (true != jtt.lang.String_intern03.test(2)) {
18930 fail(runString);
18931 return;
18932 }
18933 } catch (Throwable t) {
18934 fail(runString, t);
18935 return;
18936 }
18937 pass();
18938 }
18939
18940 static void jtt_lang_String_valueOf01() {
18941 begin("jtt.lang.String_valueOf01");
18942 String runString = null;
18943 try {
18944 // (0) == "null"
18945 runString = "(0)";
18946 if (!"null".equals(jtt.lang.String_valueOf01.test(0))) {
18947 fail(runString);
18948 return;
18949 }
18950 // (1) == "string"
18951 runString = "(1)";
18952 if (!"string".equals(jtt.lang.String_valueOf01.test(1))) {
18953 fail(runString);
18954 return;
18955 }
18956 } catch (Throwable t) {
18957 fail(runString, t);
18958 return;
18959 }
18960 pass();
18961 }
18962
18963 static void jtt_lang_System_identityHashCode01() {
18964 begin("jtt.lang.System_identityHashCode01");
18965 String runString = null;
18966 try {
18967 // (0) == true
18968 runString = "(0)";
18969 if (true != jtt.lang.System_identityHashCode01.test(0)) {
18970 fail(runString);
18971 return;
18972 }
18973 // (1) == true
18974 runString = "(1)";
18975 if (true != jtt.lang.System_identityHashCode01.test(1)) {
18976 fail(runString);
18977 return;
18978 }
18979 // (2) == true
18980 runString = "(2)";
18981 if (true != jtt.lang.System_identityHashCode01.test(2)) {
18982 fail(runString);
18983 return;
18984 }
18985 // (3) == false
18986 runString = "(3)";
18987 if (false != jtt.lang.System_identityHashCode01.test(3)) {
18988 fail(runString);
18989 return;
18990 }
18991 } catch (Throwable t) {
18992 fail(runString, t);
18993 return;
18994 }
18995 pass();
18996 }
18997
18998 static void jtt_micro_ArrayCompare01() {
18999 begin("jtt.micro.ArrayCompare01");
19000 String runString = null;
19001 try {
19002 // (0) == true
19003 runString = "(0)";
19004 if (true != jtt.micro.ArrayCompare01.test(0)) {
19005 fail(runString);
19006 return;
19007 }
19008 // (1) == false
19009 runString = "(1)";
19010 if (false != jtt.micro.ArrayCompare01.test(1)) {
19011 fail(runString);
19012 return;
19013 }
19014 } catch (Throwable t) {
19015 fail(runString, t);
19016 return;
19017 }
19018 pass();
19019 }
19020
19021 static void jtt_micro_ArrayCompare02() {
19022 begin("jtt.micro.ArrayCompare02");
19023 String runString = null;
19024 try {
19025 // (0) == true
19026 runString = "(0)";
19027 if (true != jtt.micro.ArrayCompare02.test(0)) {
19028 fail(runString);
19029 return;
19030 }
19031 // (1) == false
19032 runString = "(1)";
19033 if (false != jtt.micro.ArrayCompare02.test(1)) {
19034 fail(runString);
19035 return;
19036 }
19037 // (2) == true
19038 runString = "(2)";
19039 if (true != jtt.micro.ArrayCompare02.test(2)) {
19040 fail(runString);
19041 return;
19042 }
19043 // (3) == false
19044 runString = "(3)";
19045 if (false != jtt.micro.ArrayCompare02.test(3)) {
19046 fail(runString);
19047 return;
19048 }
19049 } catch (Throwable t) {
19050 fail(runString, t);
19051 return;
19052 }
19053 pass();
19054 }
19055
19056 static void jtt_micro_BC_invokevirtual2() {
19057 begin("jtt.micro.BC_invokevirtual2");
19058 String runString = null;
19059 try {
19060 // (0) == 0
19061 runString = "(0)";
19062 if (0 != jtt.micro.BC_invokevirtual2.test(0)) {
19063 fail(runString);
19064 return;
19065 }
19066 // (1) == 1
19067 runString = "(1)";
19068 if (1 != jtt.micro.BC_invokevirtual2.test(1)) {
19069 fail(runString);
19070 return;
19071 }
19072 // (2) == 2
19073 runString = "(2)";
19074 if (2 != jtt.micro.BC_invokevirtual2.test(2)) {
19075 fail(runString);
19076 return;
19077 }
19078 // (3) == 3
19079 runString = "(3)";
19080 if (3 != jtt.micro.BC_invokevirtual2.test(3)) {
19081 fail(runString);
19082 return;
19083 }
19084 // (-4) == -4
19085 runString = "(-4)";
19086 if (-4 != jtt.micro.BC_invokevirtual2.test(-4)) {
19087 fail(runString);
19088 return;
19089 }
19090 } catch (Throwable t) {
19091 fail(runString, t);
19092 return;
19093 }
19094 pass();
19095 }
19096
19097 static void jtt_micro_BigByteParams01() {
19098 begin("jtt.micro.BigByteParams01");
19099 String runString = null;
19100 try {
19101 // (0) == 45
19102 runString = "(0)";
19103 if (45 != jtt.micro.BigByteParams01.test(0)) {
19104 fail(runString);
19105 return;
19106 }
19107 // (1) == 45
19108 runString = "(1)";
19109 if (45 != jtt.micro.BigByteParams01.test(1)) {
19110 fail(runString);
19111 return;
19112 }
19113 // (2) == 45
19114 runString = "(2)";
19115 if (45 != jtt.micro.BigByteParams01.test(2)) {
19116 fail(runString);
19117 return;
19118 }
19119 // (3) == 45
19120 runString = "(3)";
19121 if (45 != jtt.micro.BigByteParams01.test(3)) {
19122 fail(runString);
19123 return;
19124 }
19125 // (4) == 0
19126 runString = "(4)";
19127 if (0 != jtt.micro.BigByteParams01.test(4)) {
19128 fail(runString);
19129 return;
19130 }
19131 } catch (Throwable t) {
19132 fail(runString, t);
19133 return;
19134 }
19135 pass();
19136 }
19137
19138 static void jtt_micro_BigDoubleParams02() {
19139 begin("jtt.micro.BigDoubleParams02");
19140 String runString = null;
19141 try {
19142 // (0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 1.0
19143 runString = "(0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19144 if (1.0 != jtt.micro.BigDoubleParams02.test(0, 1.0, 2.0, 3.0, 4.0,
19145 5.0, 6.0, 7.0, 8.0, 9.0)) {
19146 fail(runString);
19147 return;
19148 }
19149 // (1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 2.0
19150 runString = "(1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19151 if (2.0 != jtt.micro.BigDoubleParams02.test(1, 1.0, 2.0, 3.0, 4.0,
19152 5.0, 6.0, 7.0, 8.0, 9.0)) {
19153 fail(runString);
19154 return;
19155 }
19156 // (2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 3.0
19157 runString = "(2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19158 if (3.0 != jtt.micro.BigDoubleParams02.test(2, 1.0, 2.0, 3.0, 4.0,
19159 5.0, 6.0, 7.0, 8.0, 9.0)) {
19160 fail(runString);
19161 return;
19162 }
19163 // (3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 4.0
19164 runString = "(3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19165 if (4.0 != jtt.micro.BigDoubleParams02.test(3, 1.0, 2.0, 3.0, 4.0,
19166 5.0, 6.0, 7.0, 8.0, 9.0)) {
19167 fail(runString);
19168 return;
19169 }
19170 // (4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 5.0
19171 runString = "(4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19172 if (5.0 != jtt.micro.BigDoubleParams02.test(4, 1.0, 2.0, 3.0, 4.0,
19173 5.0, 6.0, 7.0, 8.0, 9.0)) {
19174 fail(runString);
19175 return;
19176 }
19177 // (5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 6.0
19178 runString = "(5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19179 if (6.0 != jtt.micro.BigDoubleParams02.test(5, 1.0, 2.0, 3.0, 4.0,
19180 5.0, 6.0, 7.0, 8.0, 9.0)) {
19181 fail(runString);
19182 return;
19183 }
19184 // (6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 7.0
19185 runString = "(6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19186 if (7.0 != jtt.micro.BigDoubleParams02.test(6, 1.0, 2.0, 3.0, 4.0,
19187 5.0, 6.0, 7.0, 8.0, 9.0)) {
19188 fail(runString);
19189 return;
19190 }
19191 // (7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 8.0
19192 runString = "(7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19193 if (8.0 != jtt.micro.BigDoubleParams02.test(7, 1.0, 2.0, 3.0, 4.0,
19194 5.0, 6.0, 7.0, 8.0, 9.0)) {
19195 fail(runString);
19196 return;
19197 }
19198 // (8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 9.0
19199 runString = "(8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19200 if (9.0 != jtt.micro.BigDoubleParams02.test(8, 1.0, 2.0, 3.0, 4.0,
19201 5.0, 6.0, 7.0, 8.0, 9.0)) {
19202 fail(runString);
19203 return;
19204 }
19205 } catch (Throwable t) {
19206 fail(runString, t);
19207 return;
19208 }
19209 pass();
19210 }
19211
19212 static void jtt_micro_BigFloatParams01() {
19213 begin("jtt.micro.BigFloatParams01");
19214 String runString = null;
19215 try {
19216 // (0) == 45.0
19217 runString = "(0)";
19218 if (45.0 != jtt.micro.BigFloatParams01.test(0)) {
19219 fail(runString);
19220 return;
19221 }
19222 // (1) == 45.0
19223 runString = "(1)";
19224 if (45.0 != jtt.micro.BigFloatParams01.test(1)) {
19225 fail(runString);
19226 return;
19227 }
19228 // (2) == 45.0
19229 runString = "(2)";
19230 if (45.0 != jtt.micro.BigFloatParams01.test(2)) {
19231 fail(runString);
19232 return;
19233 }
19234 // (3) == 45.0
19235 runString = "(3)";
19236 if (45.0 != jtt.micro.BigFloatParams01.test(3)) {
19237 fail(runString);
19238 return;
19239 }
19240 // (4) == 0.0
19241 runString = "(4)";
19242 if (0.0 != jtt.micro.BigFloatParams01.test(4)) {
19243 fail(runString);
19244 return;
19245 }
19246 } catch (Throwable t) {
19247 fail(runString, t);
19248 return;
19249 }
19250 pass();
19251 }
19252
19253 static void jtt_micro_BigFloatParams02() {
19254 begin("jtt.micro.BigFloatParams02");
19255 String runString = null;
19256 try {
19257 // (0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 1.0
19258 runString = "(0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19259 if (1.0f != jtt.micro.BigFloatParams02.test(0, 1.0f, 2.0f, 3.0f,
19260 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19261 fail(runString);
19262 return;
19263 }
19264 // (1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 2.0
19265 runString = "(1,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19266 if (2.0f != jtt.micro.BigFloatParams02.test(1, 1.0f, 2.0f, 3.0f,
19267 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19268 fail(runString);
19269 return;
19270 }
19271 // (2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 3.0
19272 runString = "(2,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19273 if (3.0f != jtt.micro.BigFloatParams02.test(2, 1.0f, 2.0f, 3.0f,
19274 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19275 fail(runString);
19276 return;
19277 }
19278 // (3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 4.0
19279 runString = "(3,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19280 if (4.0f != jtt.micro.BigFloatParams02.test(3, 1.0f, 2.0f, 3.0f,
19281 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19282 fail(runString);
19283 return;
19284 }
19285 // (4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 5.0
19286 runString = "(4,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19287 if (5.0f != jtt.micro.BigFloatParams02.test(4, 1.0f, 2.0f, 3.0f,
19288 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19289 fail(runString);
19290 return;
19291 }
19292 // (5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 6.0
19293 runString = "(5,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19294 if (6.0f != jtt.micro.BigFloatParams02.test(5, 1.0f, 2.0f, 3.0f,
19295 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19296 fail(runString);
19297 return;
19298 }
19299 // (6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 7.0
19300 runString = "(6,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19301 if (7.0f != jtt.micro.BigFloatParams02.test(6, 1.0f, 2.0f, 3.0f,
19302 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19303 fail(runString);
19304 return;
19305 }
19306 // (7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 8.0
19307 runString = "(7,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19308 if (8.0f != jtt.micro.BigFloatParams02.test(7, 1.0f, 2.0f, 3.0f,
19309 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19310 fail(runString);
19311 return;
19312 }
19313 // (8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0) == 9.0
19314 runString = "(8,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0)";
19315 if (9.0f != jtt.micro.BigFloatParams02.test(8, 1.0f, 2.0f, 3.0f,
19316 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f)) {
19317 fail(runString);
19318 return;
19319 }
19320 } catch (Throwable t) {
19321 fail(runString, t);
19322 return;
19323 }
19324 pass();
19325 }
19326
19327 static void jtt_micro_BigIntParams01() {
19328 begin("jtt.micro.BigIntParams01");
19329 String runString = null;
19330 try {
19331 // (0) == 45
19332 runString = "(0)";
19333 if (45 != jtt.micro.BigIntParams01.test(0)) {
19334 fail(runString);
19335 return;
19336 }
19337 // (1) == 45
19338 runString = "(1)";
19339 if (45 != jtt.micro.BigIntParams01.test(1)) {
19340 fail(runString);
19341 return;
19342 }
19343 // (2) == 45
19344 runString = "(2)";
19345 if (45 != jtt.micro.BigIntParams01.test(2)) {
19346 fail(runString);
19347 return;
19348 }
19349 // (3) == 45
19350 runString = "(3)";
19351 if (45 != jtt.micro.BigIntParams01.test(3)) {
19352 fail(runString);
19353 return;
19354 }
19355 // (4) == 0
19356 runString = "(4)";
19357 if (0 != jtt.micro.BigIntParams01.test(4)) {
19358 fail(runString);
19359 return;
19360 }
19361 } catch (Throwable t) {
19362 fail(runString, t);
19363 return;
19364 }
19365 pass();
19366 }
19367
19368 static void jtt_micro_BigIntParams02() {
19369 begin("jtt.micro.BigIntParams02");
19370 String runString = null;
19371 try {
19372 // (0,1,2,3,4,5,6,7,-8,-9) == 1
19373 runString = "(0,1,2,3,4,5,6,7,-8,-9)";
19374 if (1 != jtt.micro.BigIntParams02.test(0, 1, 2, 3, 4, 5, 6, 7, -8,
19375 -9)) {
19376 fail(runString);
19377 return;
19378 }
19379 // (1,1,2,3,4,5,6,7,-8,-9) == 2
19380 runString = "(1,1,2,3,4,5,6,7,-8,-9)";
19381 if (2 != jtt.micro.BigIntParams02.test(1, 1, 2, 3, 4, 5, 6, 7, -8,
19382 -9)) {
19383 fail(runString);
19384 return;
19385 }
19386 // (2,1,2,3,4,5,6,7,-8,-9) == 3
19387 runString = "(2,1,2,3,4,5,6,7,-8,-9)";
19388 if (3 != jtt.micro.BigIntParams02.test(2, 1, 2, 3, 4, 5, 6, 7, -8,
19389 -9)) {
19390 fail(runString);
19391 return;
19392 }
19393 // (3,1,2,3,4,5,6,7,-8,-9) == 4
19394 runString = "(3,1,2,3,4,5,6,7,-8,-9)";
19395 if (4 != jtt.micro.BigIntParams02.test(3, 1, 2, 3, 4, 5, 6, 7, -8,
19396 -9)) {
19397 fail(runString);
19398 return;
19399 }
19400 // (4,1,2,3,4,5,6,7,-8,-9) == 5
19401 runString = "(4,1,2,3,4,5,6,7,-8,-9)";
19402 if (5 != jtt.micro.BigIntParams02.test(4, 1, 2, 3, 4, 5, 6, 7, -8,
19403 -9)) {
19404 fail(runString);
19405 return;
19406 }
19407 // (5,1,2,3,4,5,6,7,-8,-9) == 6
19408 runString = "(5,1,2,3,4,5,6,7,-8,-9)";
19409 if (6 != jtt.micro.BigIntParams02.test(5, 1, 2, 3, 4, 5, 6, 7, -8,
19410 -9)) {
19411 fail(runString);
19412 return;
19413 }
19414 // (6,1,2,3,4,5,6,7,-8,-9) == 7
19415 runString = "(6,1,2,3,4,5,6,7,-8,-9)";
19416 if (7 != jtt.micro.BigIntParams02.test(6, 1, 2, 3, 4, 5, 6, 7, -8,
19417 -9)) {
19418 fail(runString);
19419 return;
19420 }
19421 // (7,1,2,3,4,5,6,7,-8,-9) == -8
19422 runString = "(7,1,2,3,4,5,6,7,-8,-9)";
19423 if (-8 != jtt.micro.BigIntParams02.test(7, 1, 2, 3, 4, 5, 6, 7, -8,
19424 -9)) {
19425 fail(runString);
19426 return;
19427 }
19428 // (8,1,2,3,4,5,6,7,-8,-9) == -9
19429 runString = "(8,1,2,3,4,5,6,7,-8,-9)";
19430 if (-9 != jtt.micro.BigIntParams02.test(8, 1, 2, 3, 4, 5, 6, 7, -8,
19431 -9)) {
19432 fail(runString);
19433 return;
19434 }
19435 } catch (Throwable t) {
19436 fail(runString, t);
19437 return;
19438 }
19439 pass();
19440 }
19441
19442 static void jtt_micro_BigInterfaceParams01() {
19443 begin("jtt.micro.BigInterfaceParams01");
19444 String runString = null;
19445 try {
19446 // (true,"0","1","2","3","4","5","6","7","8","9") == "A0123456789"
19447 runString = "(true,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")";
19448 if (!"A0123456789".equals(jtt.micro.BigInterfaceParams01.test(true,
19449 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) {
19450 fail(runString);
19451 return;
19452 }
19453 // (false,"0","1","2","3","4","5","6","7","8","9") == "B0123456789"
19454 runString = "(false,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")";
19455 if (!"B0123456789".equals(jtt.micro.BigInterfaceParams01.test(
19456 false, "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) {
19457 fail(runString);
19458 return;
19459 }
19460 } catch (Throwable t) {
19461 fail(runString, t);
19462 return;
19463 }
19464 pass();
19465 }
19466
19467 static void jtt_micro_BigLongParams02() {
19468 begin("jtt.micro.BigLongParams02");
19469 String runString = null;
19470 try {
19471 // (0,1,2,3,4,5,6,7,-8,-9) == 1
19472 runString = "(0,1,2,3,4,5,6,7,-8,-9)";
19473 if (1L != jtt.micro.BigLongParams02.test(0, 1L, 2L, 3L, 4L, 5L, 6L,
19474 7L, -8L, -9L)) {
19475 fail(runString);
19476 return;
19477 }
19478 // (1,1,2,3,4,5,6,7,-8,-9) == 2
19479 runString = "(1,1,2,3,4,5,6,7,-8,-9)";
19480 if (2L != jtt.micro.BigLongParams02.test(1, 1L, 2L, 3L, 4L, 5L, 6L,
19481 7L, -8L, -9L)) {
19482 fail(runString);
19483 return;
19484 }
19485 // (2,1,2,3,4,5,6,7,-8,-9) == 3
19486 runString = "(2,1,2,3,4,5,6,7,-8,-9)";
19487 if (3L != jtt.micro.BigLongParams02.test(2, 1L, 2L, 3L, 4L, 5L, 6L,
19488 7L, -8L, -9L)) {
19489 fail(runString);
19490 return;
19491 }
19492 // (3,1,2,3,4,5,6,7,-8,-9) == 4
19493 runString = "(3,1,2,3,4,5,6,7,-8,-9)";
19494 if (4L != jtt.micro.BigLongParams02.test(3, 1L, 2L, 3L, 4L, 5L, 6L,
19495 7L, -8L, -9L)) {
19496 fail(runString);
19497 return;
19498 }
19499 // (4,1,2,3,4,5,6,7,-8,-9) == 5
19500 runString = "(4,1,2,3,4,5,6,7,-8,-9)";
19501 if (5L != jtt.micro.BigLongParams02.test(4, 1L, 2L, 3L, 4L, 5L, 6L,
19502 7L, -8L, -9L)) {
19503 fail(runString);
19504 return;
19505 }
19506 // (5,1,2,3,4,5,6,7,-8,-9) == 6
19507 runString = "(5,1,2,3,4,5,6,7,-8,-9)";
19508 if (6L != jtt.micro.BigLongParams02.test(5, 1L, 2L, 3L, 4L, 5L, 6L,
19509 7L, -8L, -9L)) {
19510 fail(runString);
19511 return;
19512 }
19513 // (6,1,2,3,4,5,6,7,-8,-9) == 7
19514 runString = "(6,1,2,3,4,5,6,7,-8,-9)";
19515 if (7L != jtt.micro.BigLongParams02.test(6, 1L, 2L, 3L, 4L, 5L, 6L,
19516 7L, -8L, -9L)) {
19517 fail(runString);
19518 return;
19519 }
19520 // (7,1,2,3,4,5,6,7,-8,-9) == -8
19521 runString = "(7,1,2,3,4,5,6,7,-8,-9)";
19522 if (-8L != jtt.micro.BigLongParams02.test(7, 1L, 2L, 3L, 4L, 5L,
19523 6L, 7L, -8L, -9L)) {
19524 fail(runString);
19525 return;
19526 }
19527 // (8,1,2,3,4,5,6,7,-8,-9) == -9
19528 runString = "(8,1,2,3,4,5,6,7,-8,-9)";
19529 if (-9L != jtt.micro.BigLongParams02.test(8, 1L, 2L, 3L, 4L, 5L,
19530 6L, 7L, -8L, -9L)) {
19531 fail(runString);
19532 return;
19533 }
19534 } catch (Throwable t) {
19535 fail(runString, t);
19536 return;
19537 }
19538 pass();
19539 }
19540
19541 static void jtt_micro_BigMixedParams01() {
19542 begin("jtt.micro.BigMixedParams01");
19543 String runString = null;
19544 try {
19545 // (0) == 45.0
19546 runString = "(0)";
19547 if (45.0 != jtt.micro.BigMixedParams01.test(0)) {
19548 fail(runString);
19549 return;
19550 }
19551 // (1) == 45.0
19552 runString = "(1)";
19553 if (45.0 != jtt.micro.BigMixedParams01.test(1)) {
19554 fail(runString);
19555 return;
19556 }
19557 // (2) == 45.0
19558 runString = "(2)";
19559 if (45.0 != jtt.micro.BigMixedParams01.test(2)) {
19560 fail(runString);
19561 return;
19562 }
19563 // (3) == 45.0
19564 runString = "(3)";
19565 if (45.0 != jtt.micro.BigMixedParams01.test(3)) {
19566 fail(runString);
19567 return;
19568 }
19569 // (4) == 0.0
19570 runString = "(4)";
19571 if (0.0 != jtt.micro.BigMixedParams01.test(4)) {
19572 fail(runString);
19573 return;
19574 }
19575 } catch (Throwable t) {
19576 fail(runString, t);
19577 return;
19578 }
19579 pass();
19580 }
19581
19582 static void jtt_micro_BigMixedParams02() {
19583 begin("jtt.micro.BigMixedParams02");
19584 String runString = null;
19585 try {
19586 // (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
19587 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)";
19588 if (1.0f != jtt.micro.BigMixedParams02.test(0, -1, -1, -1, -1,
19589 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19590 9.0f)) {
19591 fail(runString);
19592 return;
19593 }
19594 // (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
19595 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)";
19596 if (2.0f != jtt.micro.BigMixedParams02.test(1, -1, -1, -1, -1,
19597 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19598 9.0f)) {
19599 fail(runString);
19600 return;
19601 }
19602 // (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
19603 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)";
19604 if (3.0f != jtt.micro.BigMixedParams02.test(2, -1, -1, -1, -1,
19605 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19606 9.0f)) {
19607 fail(runString);
19608 return;
19609 }
19610 // (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
19611 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)";
19612 if (4.0f != jtt.micro.BigMixedParams02.test(3, -1, -1, -1, -1,
19613 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19614 9.0f)) {
19615 fail(runString);
19616 return;
19617 }
19618 // (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
19619 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)";
19620 if (5.0f != jtt.micro.BigMixedParams02.test(4, -1, -1, -1, -1,
19621 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19622 9.0f)) {
19623 fail(runString);
19624 return;
19625 }
19626 // (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
19627 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)";
19628 if (6.0f != jtt.micro.BigMixedParams02.test(5, -1, -1, -1, -1,
19629 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19630 9.0f)) {
19631 fail(runString);
19632 return;
19633 }
19634 // (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
19635 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)";
19636 if (7.0f != jtt.micro.BigMixedParams02.test(6, -1, -1, -1, -1,
19637 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19638 9.0f)) {
19639 fail(runString);
19640 return;
19641 }
19642 // (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
19643 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)";
19644 if (8.0f != jtt.micro.BigMixedParams02.test(7, -1, -1, -1, -1,
19645 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19646 9.0f)) {
19647 fail(runString);
19648 return;
19649 }
19650 // (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
19651 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)";
19652 if (9.0f != jtt.micro.BigMixedParams02.test(8, -1, -1, -1, -1,
19653 1.0f, 2.0f, 3.0f, 4.0f, -1, -1, 5.0f, 6.0f, 7.0f, 8.0f,
19654 9.0f)) {
19655 fail(runString);
19656 return;
19657 }
19658 } catch (Throwable t) {
19659 fail(runString, t);
19660 return;
19661 }
19662 pass();
19663 }
19664
19665 static void jtt_micro_BigMixedParams03() {
19666 begin("jtt.micro.BigMixedParams03");
19667 String runString = null;
19668 try {
19669 // (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
19670 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)";
19671 if (1.0 != jtt.micro.BigMixedParams03.test(0, -1, -1, -1, -1, 1.0,
19672 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19673 fail(runString);
19674 return;
19675 }
19676 // (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
19677 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)";
19678 if (2.0 != jtt.micro.BigMixedParams03.test(1, -1, -1, -1, -1, 1.0,
19679 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19680 fail(runString);
19681 return;
19682 }
19683 // (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
19684 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)";
19685 if (3.0 != jtt.micro.BigMixedParams03.test(2, -1, -1, -1, -1, 1.0,
19686 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19687 fail(runString);
19688 return;
19689 }
19690 // (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
19691 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)";
19692 if (4.0 != jtt.micro.BigMixedParams03.test(3, -1, -1, -1, -1, 1.0,
19693 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19694 fail(runString);
19695 return;
19696 }
19697 // (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
19698 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)";
19699 if (5.0 != jtt.micro.BigMixedParams03.test(4, -1, -1, -1, -1, 1.0,
19700 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19701 fail(runString);
19702 return;
19703 }
19704 // (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
19705 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)";
19706 if (6.0 != jtt.micro.BigMixedParams03.test(5, -1, -1, -1, -1, 1.0,
19707 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19708 fail(runString);
19709 return;
19710 }
19711 // (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
19712 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)";
19713 if (7.0 != jtt.micro.BigMixedParams03.test(6, -1, -1, -1, -1, 1.0,
19714 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19715 fail(runString);
19716 return;
19717 }
19718 // (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
19719 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)";
19720 if (8.0 != jtt.micro.BigMixedParams03.test(7, -1, -1, -1, -1, 1.0,
19721 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19722 fail(runString);
19723 return;
19724 }
19725 // (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
19726 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)";
19727 if (9.0 != jtt.micro.BigMixedParams03.test(8, -1, -1, -1, -1, 1.0,
19728 2.0, 3.0, 4.0, -1, -1, 5.0, 6.0, 7.0, 8.0, 9.0)) {
19729 fail(runString);
19730 return;
19731 }
19732 } catch (Throwable t) {
19733 fail(runString, t);
19734 return;
19735 }
19736 pass();
19737 }
19738
19739 static void jtt_micro_BigObjectParams01() {
19740 begin("jtt.micro.BigObjectParams01");
19741 String runString = null;
19742 try {
19743 // ("0","1","2","3","4","5","6","7","8","9") == "0"
19744 runString = "(\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")";
19745 if (!"0".equals(jtt.micro.BigObjectParams01.test("0", "1", "2",
19746 "3", "4", "5", "6", "7", "8", "9"))) {
19747 fail(runString);
19748 return;
19749 }
19750 // ("a",null,null,null,null,null,null,null,null,null) == "a"
19751 runString = "(\"a\",null,null,null,null,null,null,null,null,null)";
19752 if (!"a".equals(jtt.micro.BigObjectParams01.test("a", null, null,
19753 null, null, null, null, null, null, null))) {
19754 fail(runString);
19755 return;
19756 }
19757 } catch (Throwable t) {
19758 fail(runString, t);
19759 return;
19760 }
19761 pass();
19762 }
19763
19764 static void jtt_micro_BigObjectParams02() {
19765 begin("jtt.micro.BigObjectParams02");
19766 String runString = null;
19767 try {
19768 // ("0","1","2","3","4","5","6","7","8","9") == "0123456789"
19769 runString = "(\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")";
19770 if (!"0123456789".equals(jtt.micro.BigObjectParams02.test("0", "1",
19771 "2", "3", "4", "5", "6", "7", "8", "9"))) {
19772 fail(runString);
19773 return;
19774 }
19775 } catch (Throwable t) {
19776 fail(runString, t);
19777 return;
19778 }
19779 pass();
19780 }
19781
19782 static void jtt_micro_BigParamsAlignment() {
19783 begin("jtt.micro.BigParamsAlignment");
19784 String runString = null;
19785 try {
19786 // (0) == 45
19787 runString = "(0)";
19788 if (45 != jtt.micro.BigParamsAlignment.test(0)) {
19789 fail(runString);
19790 return;
19791 }
19792 // (1) == 55
19793 runString = "(1)";
19794 if (55 != jtt.micro.BigParamsAlignment.test(1)) {
19795 fail(runString);
19796 return;
19797 }
19798 // (2) == 45
19799 runString = "(2)";
19800 if (45 != jtt.micro.BigParamsAlignment.test(2)) {
19801 fail(runString);
19802 return;
19803 }
19804 // (3) == 55
19805 runString = "(3)";
19806 if (55 != jtt.micro.BigParamsAlignment.test(3)) {
19807 fail(runString);
19808 return;
19809 }
19810 // (4) == 66
19811 runString = "(4)";
19812 if (66 != jtt.micro.BigParamsAlignment.test(4)) {
19813 fail(runString);
19814 return;
19815 }
19816 // (5) == 78
19817 runString = "(5)";
19818 if (78 != jtt.micro.BigParamsAlignment.test(5)) {
19819 fail(runString);
19820 return;
19821 }
19822 // (6) == 0
19823 runString = "(6)";
19824 if (0 != jtt.micro.BigParamsAlignment.test(6)) {
19825 fail(runString);
19826 return;
19827 }
19828 } catch (Throwable t) {
19829 fail(runString, t);
19830 return;
19831 }
19832 pass();
19833 }
19834
19835 static void jtt_micro_BigShortParams01() {
19836 begin("jtt.micro.BigShortParams01");
19837 String runString = null;
19838 try {
19839 // (0) == 45
19840 runString = "(0)";
19841 if (45 != jtt.micro.BigShortParams01.test(0)) {
19842 fail(runString);
19843 return;
19844 }
19845 // (1) == 45
19846 runString = "(1)";
19847 if (45 != jtt.micro.BigShortParams01.test(1)) {
19848 fail(runString);
19849 return;
19850 }
19851 // (2) == 45
19852 runString = "(2)";
19853 if (45 != jtt.micro.BigShortParams01.test(2)) {
19854 fail(runString);
19855 return;
19856 }
19857 // (3) == 45
19858 runString = "(3)";
19859 if (45 != jtt.micro.BigShortParams01.test(3)) {
19860 fail(runString);
19861 return;
19862 }
19863 // (4) == 0
19864 runString = "(4)";
19865 if (0 != jtt.micro.BigShortParams01.test(4)) {
19866 fail(runString);
19867 return;
19868 }
19869 } catch (Throwable t) {
19870 fail(runString, t);
19871 return;
19872 }
19873 pass();
19874 }
19875
19876 static void jtt_micro_BigVirtualParams01() {
19877 begin("jtt.micro.BigVirtualParams01");
19878 String runString = null;
19879 try {
19880 // (true,"0","1","2","3","4","5","6","7","8","9") == "A0123456789"
19881 runString = "(true,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")";
19882 if (!"A0123456789".equals(jtt.micro.BigVirtualParams01.test(true,
19883 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) {
19884 fail(runString);
19885 return;
19886 }
19887 // (false,"0","1","2","3","4","5","6","7","8","9") == "B0123456789"
19888 runString = "(false,\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\")";
19889 if (!"B0123456789".equals(jtt.micro.BigVirtualParams01.test(false,
19890 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"))) {
19891 fail(runString);
19892 return;
19893 }
19894 } catch (Throwable t) {
19895 fail(runString, t);
19896 return;
19897 }
19898 pass();
19899 }
19900
19901 static void jtt_micro_Bubblesort() {
19902 begin("jtt.micro.Bubblesort");
19903 String runString = null;
19904 try {
19905 // (0) == -9
19906 runString = "(0)";
19907 if (-9 != jtt.micro.Bubblesort.test(0)) {
19908 fail(runString);
19909 return;
19910 }
19911 // (1) == 0
19912 runString = "(1)";
19913 if (0 != jtt.micro.Bubblesort.test(1)) {
19914 fail(runString);
19915 return;
19916 }
19917 // (2) == 0
19918 runString = "(2)";
19919 if (0 != jtt.micro.Bubblesort.test(2)) {
19920 fail(runString);
19921 return;
19922 }
19923 // (3) == 1
19924 runString = "(3)";
19925 if (1 != jtt.micro.Bubblesort.test(3)) {
19926 fail(runString);
19927 return;
19928 }
19929 // (4) == 5
19930 runString = "(4)";
19931 if (5 != jtt.micro.Bubblesort.test(4)) {
19932 fail(runString);
19933 return;
19934 }
19935 // (5) == 8
19936 runString = "(5)";
19937 if (8 != jtt.micro.Bubblesort.test(5)) {
19938 fail(runString);
19939 return;
19940 }
19941 // (6) == 23
19942 runString = "(6)";
19943 if (23 != jtt.micro.Bubblesort.test(6)) {
19944 fail(runString);
19945 return;
19946 }
19947 // (7) == 882
19948 runString = "(7)";
19949 if (882 != jtt.micro.Bubblesort.test(7)) {
19950 fail(runString);
19951 return;
19952 }
19953 } catch (Throwable t) {
19954 fail(runString, t);
19955 return;
19956 }
19957 pass();
19958 }
19959
19960 static void jtt_micro_Fibonacci() {
19961 begin("jtt.micro.Fibonacci");
19962 String runString = null;
19963 try {
19964 // (0) == 0
19965 runString = "(0)";
19966 if (0 != jtt.micro.Fibonacci.test(0)) {
19967 fail(runString);
19968 return;
19969 }
19970 // (1) == 1
19971 runString = "(1)";
19972 if (1 != jtt.micro.Fibonacci.test(1)) {
19973 fail(runString);
19974 return;
19975 }
19976 // (2) == 1
19977 runString = "(2)";
19978 if (1 != jtt.micro.Fibonacci.test(2)) {
19979 fail(runString);
19980 return;
19981 }
19982 // (3) == 2
19983 runString = "(3)";
19984 if (2 != jtt.micro.Fibonacci.test(3)) {
19985 fail(runString);
19986 return;
19987 }
19988 // (4) == 3
19989 runString = "(4)";
19990 if (3 != jtt.micro.Fibonacci.test(4)) {
19991 fail(runString);
19992 return;
19993 }
19994 // (5) == 5
19995 runString = "(5)";
19996 if (5 != jtt.micro.Fibonacci.test(5)) {
19997 fail(runString);
19998 return;
19999 }
20000 // (6) == 8
20001 runString = "(6)";
20002 if (8 != jtt.micro.Fibonacci.test(6)) {
20003 fail(runString);
20004 return;
20005 }
20006 // (7) == 13
20007 runString = "(7)";
20008 if (13 != jtt.micro.Fibonacci.test(7)) {
20009 fail(runString);
20010 return;
20011 }
20012 } catch (Throwable t) {
20013 fail(runString, t);
20014 return;
20015 }
20016 pass();
20017 }
20018
20019 static void jtt_micro_InvokeVirtual_01() {
20020 begin("jtt.micro.InvokeVirtual_01");
20021 String runString = null;
20022 try {
20023 // (0) == 0
20024 runString = "(0)";
20025 if (0 != jtt.micro.InvokeVirtual_01.test(0)) {
20026 fail(runString);
20027 return;
20028 }
20029 // (1) == 11
20030 runString = "(1)";
20031 if (11 != jtt.micro.InvokeVirtual_01.test(1)) {
20032 fail(runString);
20033 return;
20034 }
20035 // (2) == 22
20036 runString = "(2)";
20037 if (22 != jtt.micro.InvokeVirtual_01.test(2)) {
20038 fail(runString);
20039 return;
20040 }
20041 // (3) == 42
20042 runString = "(3)";
20043 if (42 != jtt.micro.InvokeVirtual_01.test(3)) {
20044 fail(runString);
20045 return;
20046 }
20047 } catch (Throwable t) {
20048 fail(runString, t);
20049 return;
20050 }
20051 pass();
20052 }
20053
20054 static void jtt_micro_InvokeVirtual_02() {
20055 begin("jtt.micro.InvokeVirtual_02");
20056 String runString = null;
20057 try {
20058 // (0) == 0
20059 runString = "(0)";
20060 if (0L != jtt.micro.InvokeVirtual_02.test(0L)) {
20061 fail(runString);
20062 return;
20063 }
20064 // (1) == 11
20065 runString = "(1)";
20066 if (11L != jtt.micro.InvokeVirtual_02.test(1L)) {
20067 fail(runString);
20068 return;
20069 }
20070 // (2) == 22
20071 runString = "(2)";
20072 if (22L != jtt.micro.InvokeVirtual_02.test(2L)) {
20073 fail(runString);
20074 return;
20075 }
20076 // (3) == 42
20077 runString = "(3)";
20078 if (42L != jtt.micro.InvokeVirtual_02.test(3L)) {
20079 fail(runString);
20080 return;
20081 }
20082 } catch (Throwable t) {
20083 fail(runString, t);
20084 return;
20085 }
20086 pass();
20087 }
20088
20089 static void jtt_micro_Matrix01() {
20090 begin("jtt.micro.Matrix01");
20091 String runString = null;
20092 try {
20093 // (0) == 8
20094 runString = "(0)";
20095 if (8 != jtt.micro.Matrix01.test(0)) {
20096 fail(runString);
20097 return;
20098 }
20099 // (1) == 34
20100 runString = "(1)";
20101 if (34 != jtt.micro.Matrix01.test(1)) {
20102 fail(runString);
20103 return;
20104 }
20105 // (2) == 152
20106 runString = "(2)";
20107 if (152 != jtt.micro.Matrix01.test(2)) {
20108 fail(runString);
20109 return;
20110 }
20111 // (3) == 204
20112 runString = "(3)";
20113 if (204 != jtt.micro.Matrix01.test(3)) {
20114 fail(runString);
20115 return;
20116 }
20117 // (4) == 1547
20118 runString = "(4)";
20119 if (1547 != jtt.micro.Matrix01.test(4)) {
20120 fail(runString);
20121 return;
20122 }
20123 // (5) == 42
20124 runString = "(5)";
20125 if (42 != jtt.micro.Matrix01.test(5)) {
20126 fail(runString);
20127 return;
20128 }
20129 } catch (Throwable t) {
20130 fail(runString, t);
20131 return;
20132 }
20133 pass();
20134 }
20135
20136 static void jtt_micro_StrangeFrames() {
20137 begin("jtt.micro.StrangeFrames");
20138 String runString = null;
20139 try {
20140 // (0) == true
20141 runString = "(0)";
20142 if (true != jtt.micro.StrangeFrames.test(0)) {
20143 fail(runString);
20144 return;
20145 }
20146 } catch (Throwable t) {
20147 fail(runString, t);
20148 return;
20149 }
20150 pass();
20151 }
20152
20153 static void jtt_micro_String_format01() {
20154 begin("jtt.micro.String_format01");
20155 String runString = null;
20156 try {
20157 // ("World") == "Hello World"
20158 runString = "(\"World\")";
20159 if (!"Hello World".equals(jtt.micro.String_format01.test("World"))) {
20160 fail(runString);
20161 return;
20162 }
20163 // ("New World Order") == "Hello New World Order"
20164 runString = "(\"New World Order\")";
20165 if (!"Hello New World Order".equals(jtt.micro.String_format01
20166 .test("New World Order"))) {
20167 fail(runString);
20168 return;
20169 }
20170 } catch (Throwable t) {
20171 fail(runString, t);
20172 return;
20173 }
20174 pass();
20175 }
20176
20177 static void jtt_micro_String_format02() {
20178 begin("jtt.micro.String_format02");
20179 String runString = null;
20180 try {
20181 // (0) == "Hello 0"
20182 runString = "(0)";
20183 if (!"Hello 0".equals(jtt.micro.String_format02.test(0))) {
20184 fail(runString);
20185 return;
20186 }
20187 // (-11) == "Hello -11"
20188 runString = "(-11)";
20189 if (!"Hello -11".equals(jtt.micro.String_format02.test(-11))) {
20190 fail(runString);
20191 return;
20192 }
20193 // (-2147483648) == "Hello -2147483648"
20194 runString = "(-2147483648)";
20195 if (!"Hello -2147483648".equals(jtt.micro.String_format02
20196 .test(-2147483648))) {
20197 fail(runString);
20198 return;
20199 }
20200 // (2147483647) == "Hello 2147483647"
20201 runString = "(2147483647)";
20202 if (!"Hello 2147483647".equals(jtt.micro.String_format02
20203 .test(2147483647))) {
20204 fail(runString);
20205 return;
20206 }
20207 } catch (Throwable t) {
20208 fail(runString, t);
20209 return;
20210 }
20211 pass();
20212 }
20213
20214 static void jtt_micro_VarArgs_String01() {
20215 begin("jtt.micro.VarArgs_String01");
20216 String runString = null;
20217 try {
20218 // (0) == "a"
20219 runString = "(0)";
20220 if (!"a".equals(jtt.micro.VarArgs_String01.test(0))) {
20221 fail(runString);
20222 return;
20223 }
20224 // (1) == null
20225 runString = "(1)";
20226 if (null != jtt.micro.VarArgs_String01.test(1)) {
20227 fail(runString);
20228 return;
20229 }
20230 // (2) == "test"
20231 runString = "(2)";
20232 if (!"test".equals(jtt.micro.VarArgs_String01.test(2))) {
20233 fail(runString);
20234 return;
20235 }
20236 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20237 try {
20238 runString = "(3)";
20239 jtt.micro.VarArgs_String01.test(3);
20240 fail(runString);
20241 return;
20242 } catch (Throwable e) {
20243 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20244 fail(runString, e);
20245 return;
20246 }
20247 }
20248 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20249 try {
20250 runString = "(4)";
20251 jtt.micro.VarArgs_String01.test(4);
20252 fail(runString);
20253 return;
20254 } catch (Throwable e) {
20255 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20256 fail(runString, e);
20257 return;
20258 }
20259 }
20260 } catch (Throwable t) {
20261 fail(runString, t);
20262 return;
20263 }
20264 pass();
20265 }
20266
20267 static void jtt_micro_VarArgs_boolean01() {
20268 begin("jtt.micro.VarArgs_boolean01");
20269 String runString = null;
20270 try {
20271 // (0) == true
20272 runString = "(0)";
20273 if (true != jtt.micro.VarArgs_boolean01.test(0)) {
20274 fail(runString);
20275 return;
20276 }
20277 // (1) == false
20278 runString = "(1)";
20279 if (false != jtt.micro.VarArgs_boolean01.test(1)) {
20280 fail(runString);
20281 return;
20282 }
20283 // (2) == true
20284 runString = "(2)";
20285 if (true != jtt.micro.VarArgs_boolean01.test(2)) {
20286 fail(runString);
20287 return;
20288 }
20289 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20290 try {
20291 runString = "(3)";
20292 jtt.micro.VarArgs_boolean01.test(3);
20293 fail(runString);
20294 return;
20295 } catch (Throwable e) {
20296 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20297 fail(runString, e);
20298 return;
20299 }
20300 }
20301 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20302 try {
20303 runString = "(4)";
20304 jtt.micro.VarArgs_boolean01.test(4);
20305 fail(runString);
20306 return;
20307 } catch (Throwable e) {
20308 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20309 fail(runString, e);
20310 return;
20311 }
20312 }
20313 } catch (Throwable t) {
20314 fail(runString, t);
20315 return;
20316 }
20317 pass();
20318 }
20319
20320 static void jtt_micro_VarArgs_byte01() {
20321 begin("jtt.micro.VarArgs_byte01");
20322 String runString = null;
20323 try {
20324 // (0) == 1
20325 runString = "(0)";
20326 if ((byte) 1 != jtt.micro.VarArgs_byte01.test(0)) {
20327 fail(runString);
20328 return;
20329 }
20330 // (1) == 2
20331 runString = "(1)";
20332 if ((byte) 2 != jtt.micro.VarArgs_byte01.test(1)) {
20333 fail(runString);
20334 return;
20335 }
20336 // (2) == 3
20337 runString = "(2)";
20338 if ((byte) 3 != jtt.micro.VarArgs_byte01.test(2)) {
20339 fail(runString);
20340 return;
20341 }
20342 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20343 try {
20344 runString = "(3)";
20345 jtt.micro.VarArgs_byte01.test(3);
20346 fail(runString);
20347 return;
20348 } catch (Throwable e) {
20349 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20350 fail(runString, e);
20351 return;
20352 }
20353 }
20354 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20355 try {
20356 runString = "(4)";
20357 jtt.micro.VarArgs_byte01.test(4);
20358 fail(runString);
20359 return;
20360 } catch (Throwable e) {
20361 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20362 fail(runString, e);
20363 return;
20364 }
20365 }
20366 } catch (Throwable t) {
20367 fail(runString, t);
20368 return;
20369 }
20370 pass();
20371 }
20372
20373 static void jtt_micro_VarArgs_char01() {
20374 begin("jtt.micro.VarArgs_char01");
20375 String runString = null;
20376 try {
20377 // (0) == 'a'
20378 runString = "(0)";
20379 if ((char) 97 != jtt.micro.VarArgs_char01.test(0)) {
20380 fail(runString);
20381 return;
20382 }
20383 // (1) == 'b'
20384 runString = "(1)";
20385 if ((char) 98 != jtt.micro.VarArgs_char01.test(1)) {
20386 fail(runString);
20387 return;
20388 }
20389 // (2) == 'c'
20390 runString = "(2)";
20391 if ((char) 99 != jtt.micro.VarArgs_char01.test(2)) {
20392 fail(runString);
20393 return;
20394 }
20395 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20396 try {
20397 runString = "(3)";
20398 jtt.micro.VarArgs_char01.test(3);
20399 fail(runString);
20400 return;
20401 } catch (Throwable e) {
20402 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20403 fail(runString, e);
20404 return;
20405 }
20406 }
20407 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20408 try {
20409 runString = "(4)";
20410 jtt.micro.VarArgs_char01.test(4);
20411 fail(runString);
20412 return;
20413 } catch (Throwable e) {
20414 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20415 fail(runString, e);
20416 return;
20417 }
20418 }
20419 } catch (Throwable t) {
20420 fail(runString, t);
20421 return;
20422 }
20423 pass();
20424 }
20425
20426 static void jtt_micro_VarArgs_double01() {
20427 begin("jtt.micro.VarArgs_double01");
20428 String runString = null;
20429 try {
20430 // (0) == 0.0
20431 runString = "(0)";
20432 if (0.0 != jtt.micro.VarArgs_double01.test(0)) {
20433 fail(runString);
20434 return;
20435 }
20436 // (1) == 1.0
20437 runString = "(1)";
20438 if (1.0 != jtt.micro.VarArgs_double01.test(1)) {
20439 fail(runString);
20440 return;
20441 }
20442 // (2) == 2.0
20443 runString = "(2)";
20444 if (2.0 != jtt.micro.VarArgs_double01.test(2)) {
20445 fail(runString);
20446 return;
20447 }
20448 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20449 try {
20450 runString = "(3)";
20451 jtt.micro.VarArgs_double01.test(3);
20452 fail(runString);
20453 return;
20454 } catch (Throwable e) {
20455 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20456 fail(runString, e);
20457 return;
20458 }
20459 }
20460 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20461 try {
20462 runString = "(4)";
20463 jtt.micro.VarArgs_double01.test(4);
20464 fail(runString);
20465 return;
20466 } catch (Throwable e) {
20467 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20468 fail(runString, e);
20469 return;
20470 }
20471 }
20472 } catch (Throwable t) {
20473 fail(runString, t);
20474 return;
20475 }
20476 pass();
20477 }
20478
20479 static void jtt_micro_VarArgs_float01() {
20480 begin("jtt.micro.VarArgs_float01");
20481 String runString = null;
20482 try {
20483 // (0) == 0.0
20484 runString = "(0)";
20485 if (0.0f != jtt.micro.VarArgs_float01.test(0)) {
20486 fail(runString);
20487 return;
20488 }
20489 // (1) == 1.0
20490 runString = "(1)";
20491 if (1.0f != jtt.micro.VarArgs_float01.test(1)) {
20492 fail(runString);
20493 return;
20494 }
20495 // (2) == 2.0
20496 runString = "(2)";
20497 if (2.0f != jtt.micro.VarArgs_float01.test(2)) {
20498 fail(runString);
20499 return;
20500 }
20501 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20502 try {
20503 runString = "(3)";
20504 jtt.micro.VarArgs_float01.test(3);
20505 fail(runString);
20506 return;
20507 } catch (Throwable e) {
20508 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20509 fail(runString, e);
20510 return;
20511 }
20512 }
20513 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20514 try {
20515 runString = "(4)";
20516 jtt.micro.VarArgs_float01.test(4);
20517 fail(runString);
20518 return;
20519 } catch (Throwable e) {
20520 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20521 fail(runString, e);
20522 return;
20523 }
20524 }
20525 } catch (Throwable t) {
20526 fail(runString, t);
20527 return;
20528 }
20529 pass();
20530 }
20531
20532 static void jtt_micro_VarArgs_int01() {
20533 begin("jtt.micro.VarArgs_int01");
20534 String runString = null;
20535 try {
20536 // (0) == 0
20537 runString = "(0)";
20538 if (0 != jtt.micro.VarArgs_int01.test(0)) {
20539 fail(runString);
20540 return;
20541 }
20542 // (1) == 1
20543 runString = "(1)";
20544 if (1 != jtt.micro.VarArgs_int01.test(1)) {
20545 fail(runString);
20546 return;
20547 }
20548 // (2) == 2
20549 runString = "(2)";
20550 if (2 != jtt.micro.VarArgs_int01.test(2)) {
20551 fail(runString);
20552 return;
20553 }
20554 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20555 try {
20556 runString = "(3)";
20557 jtt.micro.VarArgs_int01.test(3);
20558 fail(runString);
20559 return;
20560 } catch (Throwable e) {
20561 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20562 fail(runString, e);
20563 return;
20564 }
20565 }
20566 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20567 try {
20568 runString = "(4)";
20569 jtt.micro.VarArgs_int01.test(4);
20570 fail(runString);
20571 return;
20572 } catch (Throwable e) {
20573 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20574 fail(runString, e);
20575 return;
20576 }
20577 }
20578 } catch (Throwable t) {
20579 fail(runString, t);
20580 return;
20581 }
20582 pass();
20583 }
20584
20585 static void jtt_micro_VarArgs_long01() {
20586 begin("jtt.micro.VarArgs_long01");
20587 String runString = null;
20588 try {
20589 // (0) == 0
20590 runString = "(0)";
20591 if (0L != jtt.micro.VarArgs_long01.test(0)) {
20592 fail(runString);
20593 return;
20594 }
20595 // (1) == 1
20596 runString = "(1)";
20597 if (1L != jtt.micro.VarArgs_long01.test(1)) {
20598 fail(runString);
20599 return;
20600 }
20601 // (2) == 2
20602 runString = "(2)";
20603 if (2L != jtt.micro.VarArgs_long01.test(2)) {
20604 fail(runString);
20605 return;
20606 }
20607 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20608 try {
20609 runString = "(3)";
20610 jtt.micro.VarArgs_long01.test(3);
20611 fail(runString);
20612 return;
20613 } catch (Throwable e) {
20614 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20615 fail(runString, e);
20616 return;
20617 }
20618 }
20619 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20620 try {
20621 runString = "(4)";
20622 jtt.micro.VarArgs_long01.test(4);
20623 fail(runString);
20624 return;
20625 } catch (Throwable e) {
20626 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20627 fail(runString, e);
20628 return;
20629 }
20630 }
20631 } catch (Throwable t) {
20632 fail(runString, t);
20633 return;
20634 }
20635 pass();
20636 }
20637
20638 static void jtt_micro_VarArgs_short01() {
20639 begin("jtt.micro.VarArgs_short01");
20640 String runString = null;
20641 try {
20642 // (0) == 0
20643 runString = "(0)";
20644 if ((short) 0 != jtt.micro.VarArgs_short01.test(0)) {
20645 fail(runString);
20646 return;
20647 }
20648 // (1) == 1
20649 runString = "(1)";
20650 if ((short) 1 != jtt.micro.VarArgs_short01.test(1)) {
20651 fail(runString);
20652 return;
20653 }
20654 // (2) == 2
20655 runString = "(2)";
20656 if ((short) 2 != jtt.micro.VarArgs_short01.test(2)) {
20657 fail(runString);
20658 return;
20659 }
20660 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20661 try {
20662 runString = "(3)";
20663 jtt.micro.VarArgs_short01.test(3);
20664 fail(runString);
20665 return;
20666 } catch (Throwable e) {
20667 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20668 fail(runString, e);
20669 return;
20670 }
20671 }
20672 // (4) == !java.lang.ArrayIndexOutOfBoundsException
20673 try {
20674 runString = "(4)";
20675 jtt.micro.VarArgs_short01.test(4);
20676 fail(runString);
20677 return;
20678 } catch (Throwable e) {
20679 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20680 fail(runString, e);
20681 return;
20682 }
20683 }
20684 } catch (Throwable t) {
20685 fail(runString, t);
20686 return;
20687 }
20688 pass();
20689 }
20690
20691 static void jtt_reflect_Array_get01() {
20692 begin("jtt.reflect.Array_get01");
20693 String runString = null;
20694 try {
20695 // (0) == "0"
20696 runString = "(0)";
20697 if (!"0".equals(jtt.reflect.Array_get01.test(0))) {
20698 fail(runString);
20699 return;
20700 }
20701 // (1) == "1"
20702 runString = "(1)";
20703 if (!"1".equals(jtt.reflect.Array_get01.test(1))) {
20704 fail(runString);
20705 return;
20706 }
20707 // (2) == "2"
20708 runString = "(2)";
20709 if (!"2".equals(jtt.reflect.Array_get01.test(2))) {
20710 fail(runString);
20711 return;
20712 }
20713 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20714 try {
20715 runString = "(3)";
20716 jtt.reflect.Array_get01.test(3);
20717 fail(runString);
20718 return;
20719 } catch (Throwable e) {
20720 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20721 fail(runString, e);
20722 return;
20723 }
20724 }
20725 } catch (Throwable t) {
20726 fail(runString, t);
20727 return;
20728 }
20729 pass();
20730 }
20731
20732 static void jtt_reflect_Array_get02() {
20733 begin("jtt.reflect.Array_get02");
20734 String runString = null;
20735 try {
20736 // (0) == 11
20737 runString = "(0)";
20738 if (11 != jtt.reflect.Array_get02.test(0)) {
20739 fail(runString);
20740 return;
20741 }
20742 // (1) == 21
20743 runString = "(1)";
20744 if (21 != jtt.reflect.Array_get02.test(1)) {
20745 fail(runString);
20746 return;
20747 }
20748 // (2) == 42
20749 runString = "(2)";
20750 if (42 != jtt.reflect.Array_get02.test(2)) {
20751 fail(runString);
20752 return;
20753 }
20754 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20755 try {
20756 runString = "(3)";
20757 jtt.reflect.Array_get02.test(3);
20758 fail(runString);
20759 return;
20760 } catch (Throwable e) {
20761 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20762 fail(runString, e);
20763 return;
20764 }
20765 }
20766 } catch (Throwable t) {
20767 fail(runString, t);
20768 return;
20769 }
20770 pass();
20771 }
20772
20773 static void jtt_reflect_Array_get03() {
20774 begin("jtt.reflect.Array_get03");
20775 String runString = null;
20776 try {
20777 // (0) == 11
20778 runString = "(0)";
20779 if ((byte) 11 != jtt.reflect.Array_get03.test(0)) {
20780 fail(runString);
20781 return;
20782 }
20783 // (1) == 21
20784 runString = "(1)";
20785 if ((byte) 21 != jtt.reflect.Array_get03.test(1)) {
20786 fail(runString);
20787 return;
20788 }
20789 // (2) == 42
20790 runString = "(2)";
20791 if ((byte) 42 != jtt.reflect.Array_get03.test(2)) {
20792 fail(runString);
20793 return;
20794 }
20795 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20796 try {
20797 runString = "(3)";
20798 jtt.reflect.Array_get03.test(3);
20799 fail(runString);
20800 return;
20801 } catch (Throwable e) {
20802 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20803 fail(runString, e);
20804 return;
20805 }
20806 }
20807 } catch (Throwable t) {
20808 fail(runString, t);
20809 return;
20810 }
20811 pass();
20812 }
20813
20814 static void jtt_reflect_Array_getBoolean01() {
20815 begin("jtt.reflect.Array_getBoolean01");
20816 String runString = null;
20817 try {
20818 // (0) == true
20819 runString = "(0)";
20820 if (true != jtt.reflect.Array_getBoolean01.test(0)) {
20821 fail(runString);
20822 return;
20823 }
20824 // (1) == false
20825 runString = "(1)";
20826 if (false != jtt.reflect.Array_getBoolean01.test(1)) {
20827 fail(runString);
20828 return;
20829 }
20830 // (2) == true
20831 runString = "(2)";
20832 if (true != jtt.reflect.Array_getBoolean01.test(2)) {
20833 fail(runString);
20834 return;
20835 }
20836 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20837 try {
20838 runString = "(3)";
20839 jtt.reflect.Array_getBoolean01.test(3);
20840 fail(runString);
20841 return;
20842 } catch (Throwable e) {
20843 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20844 fail(runString, e);
20845 return;
20846 }
20847 }
20848 } catch (Throwable t) {
20849 fail(runString, t);
20850 return;
20851 }
20852 pass();
20853 }
20854
20855 static void jtt_reflect_Array_getByte01() {
20856 begin("jtt.reflect.Array_getByte01");
20857 String runString = null;
20858 try {
20859 // (0) == 11
20860 runString = "(0)";
20861 if ((byte) 11 != jtt.reflect.Array_getByte01.test(0)) {
20862 fail(runString);
20863 return;
20864 }
20865 // (1) == 21
20866 runString = "(1)";
20867 if ((byte) 21 != jtt.reflect.Array_getByte01.test(1)) {
20868 fail(runString);
20869 return;
20870 }
20871 // (2) == 42
20872 runString = "(2)";
20873 if ((byte) 42 != jtt.reflect.Array_getByte01.test(2)) {
20874 fail(runString);
20875 return;
20876 }
20877 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20878 try {
20879 runString = "(3)";
20880 jtt.reflect.Array_getByte01.test(3);
20881 fail(runString);
20882 return;
20883 } catch (Throwable e) {
20884 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20885 fail(runString, e);
20886 return;
20887 }
20888 }
20889 } catch (Throwable t) {
20890 fail(runString, t);
20891 return;
20892 }
20893 pass();
20894 }
20895
20896 static void jtt_reflect_Array_getChar01() {
20897 begin("jtt.reflect.Array_getChar01");
20898 String runString = null;
20899 try {
20900 // (0) == '\13'
20901 runString = "(0)";
20902 if ((char) 11 != jtt.reflect.Array_getChar01.test(0)) {
20903 fail(runString);
20904 return;
20905 }
20906 // (1) == '\25'
20907 runString = "(1)";
20908 if ((char) 21 != jtt.reflect.Array_getChar01.test(1)) {
20909 fail(runString);
20910 return;
20911 }
20912 // (2) == '*'
20913 runString = "(2)";
20914 if ((char) 42 != jtt.reflect.Array_getChar01.test(2)) {
20915 fail(runString);
20916 return;
20917 }
20918 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20919 try {
20920 runString = "(3)";
20921 jtt.reflect.Array_getChar01.test(3);
20922 fail(runString);
20923 return;
20924 } catch (Throwable e) {
20925 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20926 fail(runString, e);
20927 return;
20928 }
20929 }
20930 } catch (Throwable t) {
20931 fail(runString, t);
20932 return;
20933 }
20934 pass();
20935 }
20936
20937 static void jtt_reflect_Array_getDouble01() {
20938 begin("jtt.reflect.Array_getDouble01");
20939 String runString = null;
20940 try {
20941 // (0) == 11.1
20942 runString = "(0)";
20943 if (11.1 != jtt.reflect.Array_getDouble01.test(0)) {
20944 fail(runString);
20945 return;
20946 }
20947 // (1) == 21.1
20948 runString = "(1)";
20949 if (21.1 != jtt.reflect.Array_getDouble01.test(1)) {
20950 fail(runString);
20951 return;
20952 }
20953 // (2) == 42.1
20954 runString = "(2)";
20955 if (42.1 != jtt.reflect.Array_getDouble01.test(2)) {
20956 fail(runString);
20957 return;
20958 }
20959 // (3) == !java.lang.ArrayIndexOutOfBoundsException
20960 try {
20961 runString = "(3)";
20962 jtt.reflect.Array_getDouble01.test(3);
20963 fail(runString);
20964 return;
20965 } catch (Throwable e) {
20966 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
20967 fail(runString, e);
20968 return;
20969 }
20970 }
20971 } catch (Throwable t) {
20972 fail(runString, t);
20973 return;
20974 }
20975 pass();
20976 }
20977
20978 static void jtt_reflect_Array_getFloat01() {
20979 begin("jtt.reflect.Array_getFloat01");
20980 String runString = null;
20981 try {
20982 // (0) == 11.1
20983 runString = "(0)";
20984 if (11.1f != jtt.reflect.Array_getFloat01.test(0)) {
20985 fail(runString);
20986 return;
20987 }
20988 // (1) == 21.1
20989 runString = "(1)";
20990 if (21.1f != jtt.reflect.Array_getFloat01.test(1)) {
20991 fail(runString);
20992 return;
20993 }
20994 // (2) == 42.1
20995 runString = "(2)";
20996 if (42.1f != jtt.reflect.Array_getFloat01.test(2)) {
20997 fail(runString);
20998 return;
20999 }
21000 // (3) == !java.lang.ArrayIndexOutOfBoundsException
21001 try {
21002 runString = "(3)";
21003 jtt.reflect.Array_getFloat01.test(3);
21004 fail(runString);
21005 return;
21006 } catch (Throwable e) {
21007 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21008 fail(runString, e);
21009 return;
21010 }
21011 }
21012 } catch (Throwable t) {
21013 fail(runString, t);
21014 return;
21015 }
21016 pass();
21017 }
21018
21019 static void jtt_reflect_Array_getInt01() {
21020 begin("jtt.reflect.Array_getInt01");
21021 String runString = null;
21022 try {
21023 // (0) == 11
21024 runString = "(0)";
21025 if (11 != jtt.reflect.Array_getInt01.test(0)) {
21026 fail(runString);
21027 return;
21028 }
21029 // (1) == 21
21030 runString = "(1)";
21031 if (21 != jtt.reflect.Array_getInt01.test(1)) {
21032 fail(runString);
21033 return;
21034 }
21035 // (2) == 42
21036 runString = "(2)";
21037 if (42 != jtt.reflect.Array_getInt01.test(2)) {
21038 fail(runString);
21039 return;
21040 }
21041 // (3) == !java.lang.ArrayIndexOutOfBoundsException
21042 try {
21043 runString = "(3)";
21044 jtt.reflect.Array_getInt01.test(3);
21045 fail(runString);
21046 return;
21047 } catch (Throwable e) {
21048 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21049 fail(runString, e);
21050 return;
21051 }
21052 }
21053 } catch (Throwable t) {
21054 fail(runString, t);
21055 return;
21056 }
21057 pass();
21058 }
21059
21060 static void jtt_reflect_Array_getLength01() {
21061 begin("jtt.reflect.Array_getLength01");
21062 String runString = null;
21063 try {
21064 // (0) == 3
21065 runString = "(0)";
21066 if (3 != jtt.reflect.Array_getLength01.test(0)) {
21067 fail(runString);
21068 return;
21069 }
21070 // (1) == 4
21071 runString = "(1)";
21072 if (4 != jtt.reflect.Array_getLength01.test(1)) {
21073 fail(runString);
21074 return;
21075 }
21076 // (2) == 1
21077 runString = "(2)";
21078 if (1 != jtt.reflect.Array_getLength01.test(2)) {
21079 fail(runString);
21080 return;
21081 }
21082 // (3) == !java.lang.NullPointerException
21083 try {
21084 runString = "(3)";
21085 jtt.reflect.Array_getLength01.test(3);
21086 fail(runString);
21087 return;
21088 } catch (Throwable e) {
21089 if (e.getClass() != java.lang.NullPointerException.class) {
21090 fail(runString, e);
21091 return;
21092 }
21093 }
21094 } catch (Throwable t) {
21095 fail(runString, t);
21096 return;
21097 }
21098 pass();
21099 }
21100
21101 static void jtt_reflect_Array_getLong01() {
21102 begin("jtt.reflect.Array_getLong01");
21103 String runString = null;
21104 try {
21105 // (0) == 11
21106 runString = "(0)";
21107 if (11L != jtt.reflect.Array_getLong01.test(0)) {
21108 fail(runString);
21109 return;
21110 }
21111 // (1) == 21
21112 runString = "(1)";
21113 if (21L != jtt.reflect.Array_getLong01.test(1)) {
21114 fail(runString);
21115 return;
21116 }
21117 // (2) == 42
21118 runString = "(2)";
21119 if (42L != jtt.reflect.Array_getLong01.test(2)) {
21120 fail(runString);
21121 return;
21122 }
21123 // (3) == !java.lang.ArrayIndexOutOfBoundsException
21124 try {
21125 runString = "(3)";
21126 jtt.reflect.Array_getLong01.test(3);
21127 fail(runString);
21128 return;
21129 } catch (Throwable e) {
21130 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21131 fail(runString, e);
21132 return;
21133 }
21134 }
21135 } catch (Throwable t) {
21136 fail(runString, t);
21137 return;
21138 }
21139 pass();
21140 }
21141
21142 static void jtt_reflect_Array_getShort01() {
21143 begin("jtt.reflect.Array_getShort01");
21144 String runString = null;
21145 try {
21146 // (0) == 11
21147 runString = "(0)";
21148 if ((short) 11 != jtt.reflect.Array_getShort01.test(0)) {
21149 fail(runString);
21150 return;
21151 }
21152 // (1) == 21
21153 runString = "(1)";
21154 if ((short) 21 != jtt.reflect.Array_getShort01.test(1)) {
21155 fail(runString);
21156 return;
21157 }
21158 // (2) == 42
21159 runString = "(2)";
21160 if ((short) 42 != jtt.reflect.Array_getShort01.test(2)) {
21161 fail(runString);
21162 return;
21163 }
21164 // (3) == !java.lang.ArrayIndexOutOfBoundsException
21165 try {
21166 runString = "(3)";
21167 jtt.reflect.Array_getShort01.test(3);
21168 fail(runString);
21169 return;
21170 } catch (Throwable e) {
21171 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21172 fail(runString, e);
21173 return;
21174 }
21175 }
21176 } catch (Throwable t) {
21177 fail(runString, t);
21178 return;
21179 }
21180 pass();
21181 }
21182
21183 static void jtt_reflect_Array_newInstance01() {
21184 begin("jtt.reflect.Array_newInstance01");
21185 String runString = null;
21186 try {
21187 // (1) == true
21188 runString = "(1)";
21189 if (true != jtt.reflect.Array_newInstance01.test(1)) {
21190 fail(runString);
21191 return;
21192 }
21193 } catch (Throwable t) {
21194 fail(runString, t);
21195 return;
21196 }
21197 pass();
21198 }
21199
21200 static void jtt_reflect_Array_newInstance02() {
21201 begin("jtt.reflect.Array_newInstance02");
21202 String runString = null;
21203 try {
21204 // (1) == true
21205 runString = "(1)";
21206 if (true != jtt.reflect.Array_newInstance02.test(1)) {
21207 fail(runString);
21208 return;
21209 }
21210 } catch (Throwable t) {
21211 fail(runString, t);
21212 return;
21213 }
21214 pass();
21215 }
21216
21217 static void jtt_reflect_Array_newInstance03() {
21218 begin("jtt.reflect.Array_newInstance03");
21219 String runString = null;
21220 try {
21221 // (1) == true
21222 runString = "(1)";
21223 if (true != jtt.reflect.Array_newInstance03.test(1)) {
21224 fail(runString);
21225 return;
21226 }
21227 } catch (Throwable t) {
21228 fail(runString, t);
21229 return;
21230 }
21231 pass();
21232 }
21233
21234 static void jtt_reflect_Array_newInstance04() {
21235 begin("jtt.reflect.Array_newInstance04");
21236 String runString = null;
21237 try {
21238 // (1,0) == true
21239 runString = "(1,0)";
21240 if (true != jtt.reflect.Array_newInstance04.test(1, 0)) {
21241 fail(runString);
21242 return;
21243 }
21244 } catch (Throwable t) {
21245 fail(runString, t);
21246 return;
21247 }
21248 pass();
21249 }
21250
21251 static void jtt_reflect_Array_newInstance05() {
21252 begin("jtt.reflect.Array_newInstance05");
21253 String runString = null;
21254 try {
21255 // (1,3) == true
21256 runString = "(1,3)";
21257 if (true != jtt.reflect.Array_newInstance05.test(1, 3)) {
21258 fail(runString);
21259 return;
21260 }
21261 } catch (Throwable t) {
21262 fail(runString, t);
21263 return;
21264 }
21265 pass();
21266 }
21267
21268 static void jtt_reflect_Array_newInstance06() {
21269 begin("jtt.reflect.Array_newInstance06");
21270 String runString = null;
21271 try {
21272 // (1) == true
21273 runString = "(1)";
21274 if (true != jtt.reflect.Array_newInstance06.test(1)) {
21275 fail(runString);
21276 return;
21277 }
21278 } catch (Throwable t) {
21279 fail(runString, t);
21280 return;
21281 }
21282 pass();
21283 }
21284
21285 static void jtt_reflect_Array_set01() {
21286 begin("jtt.reflect.Array_set01");
21287 String runString = null;
21288 try {
21289 // (0,"1") == "1"
21290 runString = "(0,\"1\")";
21291 if (!"1".equals(jtt.reflect.Array_set01.test(0, "1"))) {
21292 fail(runString);
21293 return;
21294 }
21295 // (1,"2") == "2"
21296 runString = "(1,\"2\")";
21297 if (!"2".equals(jtt.reflect.Array_set01.test(1, "2"))) {
21298 fail(runString);
21299 return;
21300 }
21301 // (0,"XXd") == "XXd"
21302 runString = "(0,\"XXd\")";
21303 if (!"XXd".equals(jtt.reflect.Array_set01.test(0, "XXd"))) {
21304 fail(runString);
21305 return;
21306 }
21307 // (3,"--") == !java.lang.ArrayIndexOutOfBoundsException
21308 try {
21309 runString = "(3,\"--\")";
21310 jtt.reflect.Array_set01.test(3, "--");
21311 fail(runString);
21312 return;
21313 } catch (Throwable e) {
21314 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21315 fail(runString, e);
21316 return;
21317 }
21318 }
21319 } catch (Throwable t) {
21320 fail(runString, t);
21321 return;
21322 }
21323 pass();
21324 }
21325
21326 static void jtt_reflect_Array_set02() {
21327 begin("jtt.reflect.Array_set02");
21328 String runString = null;
21329 try {
21330 // (0,11) == 11
21331 runString = "(0,11)";
21332 if (11 != jtt.reflect.Array_set02.test(0, 11)) {
21333 fail(runString);
21334 return;
21335 }
21336 // (1,21) == 21
21337 runString = "(1,21)";
21338 if (21 != jtt.reflect.Array_set02.test(1, 21)) {
21339 fail(runString);
21340 return;
21341 }
21342 // (0,42) == 42
21343 runString = "(0,42)";
21344 if (42 != jtt.reflect.Array_set02.test(0, 42)) {
21345 fail(runString);
21346 return;
21347 }
21348 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException
21349 try {
21350 runString = "(3,0)";
21351 jtt.reflect.Array_set02.test(3, 0);
21352 fail(runString);
21353 return;
21354 } catch (Throwable e) {
21355 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21356 fail(runString, e);
21357 return;
21358 }
21359 }
21360 } catch (Throwable t) {
21361 fail(runString, t);
21362 return;
21363 }
21364 pass();
21365 }
21366
21367 static void jtt_reflect_Array_set03() {
21368 begin("jtt.reflect.Array_set03");
21369 String runString = null;
21370 try {
21371 // (0,11) == 11
21372 runString = "(0,11)";
21373 if ((byte) 11 != jtt.reflect.Array_set03.test(0, (byte) 11)) {
21374 fail(runString);
21375 return;
21376 }
21377 // (1,21) == 21
21378 runString = "(1,21)";
21379 if ((byte) 21 != jtt.reflect.Array_set03.test(1, (byte) 21)) {
21380 fail(runString);
21381 return;
21382 }
21383 // (0,42) == 42
21384 runString = "(0,42)";
21385 if ((byte) 42 != jtt.reflect.Array_set03.test(0, (byte) 42)) {
21386 fail(runString);
21387 return;
21388 }
21389 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException
21390 try {
21391 runString = "(3,0)";
21392 jtt.reflect.Array_set03.test(3, (byte) 0);
21393 fail(runString);
21394 return;
21395 } catch (Throwable e) {
21396 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21397 fail(runString, e);
21398 return;
21399 }
21400 }
21401 } catch (Throwable t) {
21402 fail(runString, t);
21403 return;
21404 }
21405 pass();
21406 }
21407
21408 static void jtt_reflect_Array_setBoolean01() {
21409 begin("jtt.reflect.Array_setBoolean01");
21410 String runString = null;
21411 try {
21412 // (0,true) == true
21413 runString = "(0,true)";
21414 if (true != jtt.reflect.Array_setBoolean01.test(0, true)) {
21415 fail(runString);
21416 return;
21417 }
21418 // (1,false) == false
21419 runString = "(1,false)";
21420 if (false != jtt.reflect.Array_setBoolean01.test(1, false)) {
21421 fail(runString);
21422 return;
21423 }
21424 // (2,true) == true
21425 runString = "(2,true)";
21426 if (true != jtt.reflect.Array_setBoolean01.test(2, true)) {
21427 fail(runString);
21428 return;
21429 }
21430 // (3,false) == !java.lang.ArrayIndexOutOfBoundsException
21431 try {
21432 runString = "(3,false)";
21433 jtt.reflect.Array_setBoolean01.test(3, false);
21434 fail(runString);
21435 return;
21436 } catch (Throwable e) {
21437 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21438 fail(runString, e);
21439 return;
21440 }
21441 }
21442 } catch (Throwable t) {
21443 fail(runString, t);
21444 return;
21445 }
21446 pass();
21447 }
21448
21449 static void jtt_reflect_Array_setByte01() {
21450 begin("jtt.reflect.Array_setByte01");
21451 String runString = null;
21452 try {
21453 // (0,11) == 11
21454 runString = "(0,11)";
21455 if ((byte) 11 != jtt.reflect.Array_setByte01.test(0, (byte) 11)) {
21456 fail(runString);
21457 return;
21458 }
21459 // (1,21) == 21
21460 runString = "(1,21)";
21461 if ((byte) 21 != jtt.reflect.Array_setByte01.test(1, (byte) 21)) {
21462 fail(runString);
21463 return;
21464 }
21465 // (0,42) == 42
21466 runString = "(0,42)";
21467 if ((byte) 42 != jtt.reflect.Array_setByte01.test(0, (byte) 42)) {
21468 fail(runString);
21469 return;
21470 }
21471 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException
21472 try {
21473 runString = "(3,0)";
21474 jtt.reflect.Array_setByte01.test(3, (byte) 0);
21475 fail(runString);
21476 return;
21477 } catch (Throwable e) {
21478 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21479 fail(runString, e);
21480 return;
21481 }
21482 }
21483 } catch (Throwable t) {
21484 fail(runString, t);
21485 return;
21486 }
21487 pass();
21488 }
21489
21490 static void jtt_reflect_Array_setChar01() {
21491 begin("jtt.reflect.Array_setChar01");
21492 String runString = null;
21493 try {
21494 // (0,'\13') == '\13'
21495 runString = "(0,'\13')";
21496 if ((char) 11 != jtt.reflect.Array_setChar01.test(0, (char) 11)) {
21497 fail(runString);
21498 return;
21499 }
21500 // (1,'\25') == '\25'
21501 runString = "(1,'\25')";
21502 if ((char) 21 != jtt.reflect.Array_setChar01.test(1, (char) 21)) {
21503 fail(runString);
21504 return;
21505 }
21506 // (0,'*') == '*'
21507 runString = "(0,'*')";
21508 if ((char) 42 != jtt.reflect.Array_setChar01.test(0, (char) 42)) {
21509 fail(runString);
21510 return;
21511 }
21512 // (3,'\0') == !java.lang.ArrayIndexOutOfBoundsException
21513 try {
21514 runString = "(3,'\0')";
21515 jtt.reflect.Array_setChar01.test(3, (char) 0);
21516 fail(runString);
21517 return;
21518 } catch (Throwable e) {
21519 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21520 fail(runString, e);
21521 return;
21522 }
21523 }
21524 } catch (Throwable t) {
21525 fail(runString, t);
21526 return;
21527 }
21528 pass();
21529 }
21530
21531 static void jtt_reflect_Array_setDouble01() {
21532 begin("jtt.reflect.Array_setDouble01");
21533 String runString = null;
21534 try {
21535 // (0,11.1) == 11.1
21536 runString = "(0,11.1)";
21537 if (11.1 != jtt.reflect.Array_setDouble01.test(0, 11.1)) {
21538 fail(runString);
21539 return;
21540 }
21541 // (1,21.1) == 21.1
21542 runString = "(1,21.1)";
21543 if (21.1 != jtt.reflect.Array_setDouble01.test(1, 21.1)) {
21544 fail(runString);
21545 return;
21546 }
21547 // (0,42.1) == 42.1
21548 runString = "(0,42.1)";
21549 if (42.1 != jtt.reflect.Array_setDouble01.test(0, 42.1)) {
21550 fail(runString);
21551 return;
21552 }
21553 // (3,0.1) == !java.lang.ArrayIndexOutOfBoundsException
21554 try {
21555 runString = "(3,0.1)";
21556 jtt.reflect.Array_setDouble01.test(3, 0.1);
21557 fail(runString);
21558 return;
21559 } catch (Throwable e) {
21560 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21561 fail(runString, e);
21562 return;
21563 }
21564 }
21565 } catch (Throwable t) {
21566 fail(runString, t);
21567 return;
21568 }
21569 pass();
21570 }
21571
21572 static void jtt_reflect_Array_setFloat01() {
21573 begin("jtt.reflect.Array_setFloat01");
21574 String runString = null;
21575 try {
21576 // (0,11.1) == 11.1
21577 runString = "(0,11.1)";
21578 if (11.1f != jtt.reflect.Array_setFloat01.test(0, 11.1f)) {
21579 fail(runString);
21580 return;
21581 }
21582 // (1,21.1) == 21.1
21583 runString = "(1,21.1)";
21584 if (21.1f != jtt.reflect.Array_setFloat01.test(1, 21.1f)) {
21585 fail(runString);
21586 return;
21587 }
21588 // (0,42.1) == 42.1
21589 runString = "(0,42.1)";
21590 if (42.1f != jtt.reflect.Array_setFloat01.test(0, 42.1f)) {
21591 fail(runString);
21592 return;
21593 }
21594 // (3,0.1) == !java.lang.ArrayIndexOutOfBoundsException
21595 try {
21596 runString = "(3,0.1)";
21597 jtt.reflect.Array_setFloat01.test(3, 0.1f);
21598 fail(runString);
21599 return;
21600 } catch (Throwable e) {
21601 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21602 fail(runString, e);
21603 return;
21604 }
21605 }
21606 } catch (Throwable t) {
21607 fail(runString, t);
21608 return;
21609 }
21610 pass();
21611 }
21612
21613 static void jtt_reflect_Array_setInt01() {
21614 begin("jtt.reflect.Array_setInt01");
21615 String runString = null;
21616 try {
21617 // (0,11) == 11
21618 runString = "(0,11)";
21619 if (11 != jtt.reflect.Array_setInt01.test(0, 11)) {
21620 fail(runString);
21621 return;
21622 }
21623 // (1,21) == 21
21624 runString = "(1,21)";
21625 if (21 != jtt.reflect.Array_setInt01.test(1, 21)) {
21626 fail(runString);
21627 return;
21628 }
21629 // (0,42) == 42
21630 runString = "(0,42)";
21631 if (42 != jtt.reflect.Array_setInt01.test(0, 42)) {
21632 fail(runString);
21633 return;
21634 }
21635 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException
21636 try {
21637 runString = "(3,0)";
21638 jtt.reflect.Array_setInt01.test(3, 0);
21639 fail(runString);
21640 return;
21641 } catch (Throwable e) {
21642 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21643 fail(runString, e);
21644 return;
21645 }
21646 }
21647 } catch (Throwable t) {
21648 fail(runString, t);
21649 return;
21650 }
21651 pass();
21652 }
21653
21654 static void jtt_reflect_Array_setLong01() {
21655 begin("jtt.reflect.Array_setLong01");
21656 String runString = null;
21657 try {
21658 // (0,11) == 11
21659 runString = "(0,11)";
21660 if (11L != jtt.reflect.Array_setLong01.test(0, 11L)) {
21661 fail(runString);
21662 return;
21663 }
21664 // (1,21) == 21
21665 runString = "(1,21)";
21666 if (21L != jtt.reflect.Array_setLong01.test(1, 21L)) {
21667 fail(runString);
21668 return;
21669 }
21670 // (0,42) == 42
21671 runString = "(0,42)";
21672 if (42L != jtt.reflect.Array_setLong01.test(0, 42L)) {
21673 fail(runString);
21674 return;
21675 }
21676 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException
21677 try {
21678 runString = "(3,0)";
21679 jtt.reflect.Array_setLong01.test(3, 0L);
21680 fail(runString);
21681 return;
21682 } catch (Throwable e) {
21683 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21684 fail(runString, e);
21685 return;
21686 }
21687 }
21688 } catch (Throwable t) {
21689 fail(runString, t);
21690 return;
21691 }
21692 pass();
21693 }
21694
21695 static void jtt_reflect_Array_setShort01() {
21696 begin("jtt.reflect.Array_setShort01");
21697 String runString = null;
21698 try {
21699 // (0,11) == 11
21700 runString = "(0,11)";
21701 if ((short) 11 != jtt.reflect.Array_setShort01.test(0, (short) 11)) {
21702 fail(runString);
21703 return;
21704 }
21705 // (1,21) == 21
21706 runString = "(1,21)";
21707 if ((short) 21 != jtt.reflect.Array_setShort01.test(1, (short) 21)) {
21708 fail(runString);
21709 return;
21710 }
21711 // (0,42) == 42
21712 runString = "(0,42)";
21713 if ((short) 42 != jtt.reflect.Array_setShort01.test(0, (short) 42)) {
21714 fail(runString);
21715 return;
21716 }
21717 // (3,0) == !java.lang.ArrayIndexOutOfBoundsException
21718 try {
21719 runString = "(3,0)";
21720 jtt.reflect.Array_setShort01.test(3, (short) 0);
21721 fail(runString);
21722 return;
21723 } catch (Throwable e) {
21724 if (e.getClass() != java.lang.ArrayIndexOutOfBoundsException.class) {
21725 fail(runString, e);
21726 return;
21727 }
21728 }
21729 } catch (Throwable t) {
21730 fail(runString, t);
21731 return;
21732 }
21733 pass();
21734 }
21735
21736 static void jtt_reflect_Class_getDeclaredField01() {
21737 begin("jtt.reflect.Class_getDeclaredField01");
21738 String runString = null;
21739 try {
21740 // ("test") == !java.lang.NoSuchFieldException
21741 try {
21742 runString = "(\"test\")";
21743 jtt.reflect.Class_getDeclaredField01.test("test");
21744 fail(runString);
21745 return;
21746 } catch (Throwable e) {
21747 if (e.getClass() != java.lang.NoSuchFieldException.class) {
21748 fail(runString, e);
21749 return;
21750 }
21751 }
21752 // ("field") == "field"
21753 runString = "(\"field\")";
21754 if (!"field".equals(jtt.reflect.Class_getDeclaredField01
21755 .test("field"))) {
21756 fail(runString);
21757 return;
21758 }
21759 // ("f2") == "f2"
21760 runString = "(\"f2\")";
21761 if (!"f2".equals(jtt.reflect.Class_getDeclaredField01.test("f2"))) {
21762 fail(runString);
21763 return;
21764 }
21765 } catch (Throwable t) {
21766 fail(runString, t);
21767 return;
21768 }
21769 pass();
21770 }
21771
21772 static void jtt_reflect_Class_getDeclaredMethod01() {
21773 begin("jtt.reflect.Class_getDeclaredMethod01");
21774 String runString = null;
21775 try {
21776 // ("test") == !java.lang.NoSuchMethodException
21777 try {
21778 runString = "(\"test\")";
21779 jtt.reflect.Class_getDeclaredMethod01.test("test");
21780 fail(runString);
21781 return;
21782 } catch (Throwable e) {
21783 if (e.getClass() != java.lang.NoSuchMethodException.class) {
21784 fail(runString, e);
21785 return;
21786 }
21787 }
21788 // ("main") == "main"
21789 runString = "(\"main\")";
21790 if (!"main".equals(jtt.reflect.Class_getDeclaredMethod01
21791 .test("main"))) {
21792 fail(runString);
21793 return;
21794 }
21795 // ("xx") == !java.lang.NoSuchMethodException
21796 try {
21797 runString = "(\"xx\")";
21798 jtt.reflect.Class_getDeclaredMethod01.test("xx");
21799 fail(runString);
21800 return;
21801 } catch (Throwable e) {
21802 if (e.getClass() != java.lang.NoSuchMethodException.class) {
21803 fail(runString, e);
21804 return;
21805 }
21806 }
21807 } catch (Throwable t) {
21808 fail(runString, t);
21809 return;
21810 }
21811 pass();
21812 }
21813
21814 static void jtt_reflect_Class_getField01() {
21815 begin("jtt.reflect.Class_getField01");
21816 String runString = null;
21817 try {
21818 // ("test") == !java.lang.NoSuchFieldException
21819 try {
21820 runString = "(\"test\")";
21821 jtt.reflect.Class_getField01.test("test");
21822 fail(runString);
21823 return;
21824 } catch (Throwable e) {
21825 if (e.getClass() != java.lang.NoSuchFieldException.class) {
21826 fail(runString, e);
21827 return;
21828 }
21829 }
21830 // ("field") == "field"
21831 runString = "(\"field\")";
21832 if (!"field".equals(jtt.reflect.Class_getField01.test("field"))) {
21833 fail(runString);
21834 return;
21835 }
21836 // ("field2") == "field2"
21837 runString = "(\"field2\")";
21838 if (!"field2".equals(jtt.reflect.Class_getField01.test("field2"))) {
21839 fail(runString);
21840 return;
21841 }
21842 // ("field3") == !java.lang.NoSuchFieldException
21843 try {
21844 runString = "(\"field3\")";
21845 jtt.reflect.Class_getField01.test("field3");
21846 fail(runString);
21847 return;
21848 } catch (Throwable e) {
21849 if (e.getClass() != java.lang.NoSuchFieldException.class) {
21850 fail(runString, e);
21851 return;
21852 }
21853 }
21854 } catch (Throwable t) {
21855 fail(runString, t);
21856 return;
21857 }
21858 pass();
21859 }
21860
21861 static void jtt_reflect_Class_getField02() {
21862 begin("jtt.reflect.Class_getField02");
21863 String runString = null;
21864 try {
21865 // ("test") == !java.lang.NoSuchFieldException
21866 try {
21867 runString = "(\"test\")";
21868 jtt.reflect.Class_getField02.test("test");
21869 fail(runString);
21870 return;
21871 } catch (Throwable e) {
21872 if (e.getClass() != java.lang.NoSuchFieldException.class) {
21873 fail(runString, e);
21874 return;
21875 }
21876 }
21877 // ("field") == "field"
21878 runString = "(\"field\")";
21879 if (!"field".equals(jtt.reflect.Class_getField02.test("field"))) {
21880 fail(runString);
21881 return;
21882 }
21883 // ("field2") == "field2"
21884 runString = "(\"field2\")";
21885 if (!"field2".equals(jtt.reflect.Class_getField02.test("field2"))) {
21886 fail(runString);
21887 return;
21888 }
21889 // ("field3") == !java.lang.NoSuchFieldException
21890 try {
21891 runString = "(\"field3\")";
21892 jtt.reflect.Class_getField02.test("field3");
21893 fail(runString);
21894 return;
21895 } catch (Throwable e) {
21896 if (e.getClass() != java.lang.NoSuchFieldException.class) {
21897 fail(runString, e);
21898 return;
21899 }
21900 }
21901 // ("field4") == "field4"
21902 runString = "(\"field4\")";
21903 if (!"field4".equals(jtt.reflect.Class_getField02.test("field4"))) {
21904 fail(runString);
21905 return;
21906 }
21907 } catch (Throwable t) {
21908 fail(runString, t);
21909 return;
21910 }
21911 pass();
21912 }
21913
21914 static void jtt_reflect_Class_getMethod01() {
21915 begin("jtt.reflect.Class_getMethod01");
21916 String runString = null;
21917 try {
21918 // ("test") == !java.lang.NoSuchMethodException
21919 try {
21920 runString = "(\"test\")";
21921 jtt.reflect.Class_getMethod01.test("test");
21922 fail(runString);
21923 return;
21924 } catch (Throwable e) {
21925 if (e.getClass() != java.lang.NoSuchMethodException.class) {
21926 fail(runString, e);
21927 return;
21928 }
21929 }
21930 // ("main") == "main"
21931 runString = "(\"main\")";
21932 if (!"main".equals(jtt.reflect.Class_getMethod01.test("main"))) {
21933 fail(runString);
21934 return;
21935 }
21936 // ("xx") == !java.lang.NoSuchMethodException
21937 try {
21938 runString = "(\"xx\")";
21939 jtt.reflect.Class_getMethod01.test("xx");
21940 fail(runString);
21941 return;
21942 } catch (Throwable e) {
21943 if (e.getClass() != java.lang.NoSuchMethodException.class) {
21944 fail(runString, e);
21945 return;
21946 }
21947 }
21948 } catch (Throwable t) {
21949 fail(runString, t);
21950 return;
21951 }
21952 pass();
21953 }
21954
21955 static void jtt_reflect_Class_getMethod02() {
21956 begin("jtt.reflect.Class_getMethod02");
21957 String runString = null;
21958 try {
21959 // (0) == !java.lang.NoSuchMethodException
21960 try {
21961 runString = "(0)";
21962 jtt.reflect.Class_getMethod02.test(0);
21963 fail(runString);
21964 return;
21965 } catch (Throwable e) {
21966 if (e.getClass() != java.lang.NoSuchMethodException.class) {
21967 fail(runString, e);
21968 return;
21969 }
21970 }
21971 // (1) == "test"
21972 runString = "(1)";
21973 if (!"test".equals(jtt.reflect.Class_getMethod02.test(1))) {
21974 fail(runString);
21975 return;
21976 }
21977 // (2) == !java.lang.NoSuchMethodException
21978 try {
21979 runString = "(2)";
21980 jtt.reflect.Class_getMethod02.test(2);
21981 fail(runString);
21982 return;
21983 } catch (Throwable e) {
21984 if (e.getClass() != java.lang.NoSuchMethodException.class) {
21985 fail(runString, e);
21986 return;
21987 }
21988 }
21989 // (3) == "main"
21990 runString = "(3)";
21991 if (!"main".equals(jtt.reflect.Class_getMethod02.test(3))) {
21992 fail(runString);
21993 return;
21994 }
21995 // (4) == !java.lang.NoSuchMethodException
21996 try {
21997 runString = "(4)";
21998 jtt.reflect.Class_getMethod02.test(4);
21999 fail(runString);
22000 return;
22001 } catch (Throwable e) {
22002 if (e.getClass() != java.lang.NoSuchMethodException.class) {
22003 fail(runString, e);
22004 return;
22005 }
22006 }
22007 // (5) == !java.lang.NoSuchMethodException
22008 try {
22009 runString = "(5)";
22010 jtt.reflect.Class_getMethod02.test(5);
22011 fail(runString);
22012 return;
22013 } catch (Throwable e) {
22014 if (e.getClass() != java.lang.NoSuchMethodException.class) {
22015 fail(runString, e);
22016 return;
22017 }
22018 }
22019 // (6) == null
22020 runString = "(6)";
22021 if (null != jtt.reflect.Class_getMethod02.test(6)) {
22022 fail(runString);
22023 return;
22024 }
22025 } catch (Throwable t) {
22026 fail(runString, t);
22027 return;
22028 }
22029 pass();
22030 }
22031
22032 static void jtt_reflect_Class_newInstance01() {
22033 begin("jtt.reflect.Class_newInstance01");
22034 String runString = null;
22035 try {
22036 // (0) == true
22037 runString = "(0)";
22038 if (true != jtt.reflect.Class_newInstance01.test(0)) {
22039 fail(runString);
22040 return;
22041 }
22042 // (1) == false
22043 runString = "(1)";
22044 if (false != jtt.reflect.Class_newInstance01.test(1)) {
22045 fail(runString);
22046 return;
22047 }
22048 } catch (Throwable t) {
22049 fail(runString, t);
22050 return;
22051 }
22052 pass();
22053 }
22054
22055 static void jtt_reflect_Class_newInstance02() {
22056 begin("jtt.reflect.Class_newInstance02");
22057 String runString = null;
22058 try {
22059 // (0) == !java.lang.IllegalAccessException
22060 try {
22061 runString = "(0)";
22062 jtt.reflect.Class_newInstance02.test(0);
22063 fail(runString);
22064 return;
22065 } catch (Throwable e) {
22066 if (e.getClass() != java.lang.IllegalAccessException.class) {
22067 fail(runString, e);
22068 return;
22069 }
22070 }
22071 // (1) == false
22072 runString = "(1)";
22073 if (false != jtt.reflect.Class_newInstance02.test(1)) {
22074 fail(runString);
22075 return;
22076 }
22077 } catch (Throwable t) {
22078 fail(runString, t);
22079 return;
22080 }
22081 pass();
22082 }
22083
22084 static void jtt_reflect_Class_newInstance03() {
22085 begin("jtt.reflect.Class_newInstance03");
22086 String runString = null;
22087 try {
22088 // (0) == !java.lang.InstantiationException
22089 try {
22090 runString = "(0)";
22091 jtt.reflect.Class_newInstance03.test(0);
22092 fail(runString);
22093 return;
22094 } catch (Throwable e) {
22095 if (e.getClass() != java.lang.InstantiationException.class) {
22096 fail(runString, e);
22097 return;
22098 }
22099 }
22100 // (1) == !java.lang.InstantiationException
22101 try {
22102 runString = "(1)";
22103 jtt.reflect.Class_newInstance03.test(1);
22104 fail(runString);
22105 return;
22106 } catch (Throwable e) {
22107 if (e.getClass() != java.lang.InstantiationException.class) {
22108 fail(runString, e);
22109 return;
22110 }
22111 }
22112 // (2) == !java.lang.InstantiationException
22113 try {
22114 runString = "(2)";
22115 jtt.reflect.Class_newInstance03.test(2);
22116 fail(runString);
22117 return;
22118 } catch (Throwable e) {
22119 if (e.getClass() != java.lang.InstantiationException.class) {
22120 fail(runString, e);
22121 return;
22122 }
22123 }
22124 // (3) == !java.lang.InstantiationException
22125 try {
22126 runString = "(3)";
22127 jtt.reflect.Class_newInstance03.test(3);
22128 fail(runString);
22129 return;
22130 } catch (Throwable e) {
22131 if (e.getClass() != java.lang.InstantiationException.class) {
22132 fail(runString, e);
22133 return;
22134 }
22135 }
22136 // (4) == false
22137 runString = "(4)";
22138 if (false != jtt.reflect.Class_newInstance03.test(4)) {
22139 fail(runString);
22140 return;
22141 }
22142 } catch (Throwable t) {
22143 fail(runString, t);
22144 return;
22145 }
22146 pass();
22147 }
22148
22149 static void jtt_reflect_Class_newInstance06() {
22150 begin("jtt.reflect.Class_newInstance06");
22151 String runString = null;
22152 try {
22153 // (0) == !java.lang.InstantiationException
22154 try {
22155 runString = "(0)";
22156 jtt.reflect.Class_newInstance06.test(0);
22157 fail(runString);
22158 return;
22159 } catch (Throwable e) {
22160 if (e.getClass() != java.lang.InstantiationException.class) {
22161 fail(runString, e);
22162 return;
22163 }
22164 }
22165 // (4) == false
22166 runString = "(4)";
22167 if (false != jtt.reflect.Class_newInstance06.test(4)) {
22168 fail(runString);
22169 return;
22170 }
22171 } catch (Throwable t) {
22172 fail(runString, t);
22173 return;
22174 }
22175 pass();
22176 }
22177
22178 static void jtt_reflect_Class_newInstance07() {
22179 begin("jtt.reflect.Class_newInstance07");
22180 String runString = null;
22181 try {
22182 // (0) == !java.lang.Exception
22183 try {
22184 runString = "(0)";
22185 jtt.reflect.Class_newInstance07.test(0);
22186 fail(runString);
22187 return;
22188 } catch (Throwable e) {
22189 if (e.getClass() != java.lang.Exception.class) {
22190 fail(runString, e);
22191 return;
22192 }
22193 }
22194 // (4) == false
22195 runString = "(4)";
22196 if (false != jtt.reflect.Class_newInstance07.test(4)) {
22197 fail(runString);
22198 return;
22199 }
22200 } catch (Throwable t) {
22201 fail(runString, t);
22202 return;
22203 }
22204 pass();
22205 }
22206
22207 static void jtt_reflect_Field_get01() {
22208 begin("jtt.reflect.Field_get01");
22209 String runString = null;
22210 try {
22211 // (0) == true
22212 runString = "(0)";
22213 if (true != jtt.reflect.Field_get01.test(0)) {
22214 fail(runString);
22215 return;
22216 }
22217 // (1) == true
22218 runString = "(1)";
22219 if (true != jtt.reflect.Field_get01.test(1)) {
22220 fail(runString);
22221 return;
22222 }
22223 // (2) == true
22224 runString = "(2)";
22225 if (true != jtt.reflect.Field_get01.test(2)) {
22226 fail(runString);
22227 return;
22228 }
22229 // (3) == true
22230 runString = "(3)";
22231 if (true != jtt.reflect.Field_get01.test(3)) {
22232 fail(runString);
22233 return;
22234 }
22235 // (4) == true
22236 runString = "(4)";
22237 if (true != jtt.reflect.Field_get01.test(4)) {
22238 fail(runString);
22239 return;
22240 }
22241 // (5) == true
22242 runString = "(5)";
22243 if (true != jtt.reflect.Field_get01.test(5)) {
22244 fail(runString);
22245 return;
22246 }
22247 // (6) == true
22248 runString = "(6)";
22249 if (true != jtt.reflect.Field_get01.test(6)) {
22250 fail(runString);
22251 return;
22252 }
22253 // (7) == true
22254 runString = "(7)";
22255 if (true != jtt.reflect.Field_get01.test(7)) {
22256 fail(runString);
22257 return;
22258 }
22259 // (8) == false
22260 runString = "(8)";
22261 if (false != jtt.reflect.Field_get01.test(8)) {
22262 fail(runString);
22263 return;
22264 }
22265 } catch (Throwable t) {
22266 fail(runString, t);
22267 return;
22268 }
22269 pass();
22270 }
22271
22272 static void jtt_reflect_Field_get02() {
22273 begin("jtt.reflect.Field_get02");
22274 String runString = null;
22275 try {
22276 // (0) == true
22277 runString = "(0)";
22278 if (true != jtt.reflect.Field_get02.test(0)) {
22279 fail(runString);
22280 return;
22281 }
22282 // (1) == true
22283 runString = "(1)";
22284 if (true != jtt.reflect.Field_get02.test(1)) {
22285 fail(runString);
22286 return;
22287 }
22288 // (2) == true
22289 runString = "(2)";
22290 if (true != jtt.reflect.Field_get02.test(2)) {
22291 fail(runString);
22292 return;
22293 }
22294 // (3) == true
22295 runString = "(3)";
22296 if (true != jtt.reflect.Field_get02.test(3)) {
22297 fail(runString);
22298 return;
22299 }
22300 // (4) == true
22301 runString = "(4)";
22302 if (true != jtt.reflect.Field_get02.test(4)) {
22303 fail(runString);
22304 return;
22305 }
22306 // (5) == true
22307 runString = "(5)";
22308 if (true != jtt.reflect.Field_get02.test(5)) {
22309 fail(runString);
22310 return;
22311 }
22312 // (6) == true
22313 runString = "(6)";
22314 if (true != jtt.reflect.Field_get02.test(6)) {
22315 fail(runString);
22316 return;
22317 }
22318 // (7) == true
22319 runString = "(7)";
22320 if (true != jtt.reflect.Field_get02.test(7)) {
22321 fail(runString);
22322 return;
22323 }
22324 // (8) == false
22325 runString = "(8)";
22326 if (false != jtt.reflect.Field_get02.test(8)) {
22327 fail(runString);
22328 return;
22329 }
22330 } catch (Throwable t) {
22331 fail(runString, t);
22332 return;
22333 }
22334 pass();
22335 }
22336
22337 static void jtt_reflect_Field_get03() {
22338 begin("jtt.reflect.Field_get03");
22339 String runString = null;
22340 try {
22341 // (0) == true
22342 runString = "(0)";
22343 if (true != jtt.reflect.Field_get03.test(0)) {
22344 fail(runString);
22345 return;
22346 }
22347 // (1) == true
22348 runString = "(1)";
22349 if (true != jtt.reflect.Field_get03.test(1)) {
22350 fail(runString);
22351 return;
22352 }
22353 // (2) == true
22354 runString = "(2)";
22355 if (true != jtt.reflect.Field_get03.test(2)) {
22356 fail(runString);
22357 return;
22358 }
22359 // (3) == true
22360 runString = "(3)";
22361 if (true != jtt.reflect.Field_get03.test(3)) {
22362 fail(runString);
22363 return;
22364 }
22365 // (4) == true
22366 runString = "(4)";
22367 if (true != jtt.reflect.Field_get03.test(4)) {
22368 fail(runString);
22369 return;
22370 }
22371 // (5) == true
22372 runString = "(5)";
22373 if (true != jtt.reflect.Field_get03.test(5)) {
22374 fail(runString);
22375 return;
22376 }
22377 // (6) == true
22378 runString = "(6)";
22379 if (true != jtt.reflect.Field_get03.test(6)) {
22380 fail(runString);
22381 return;
22382 }
22383 // (7) == true
22384 runString = "(7)";
22385 if (true != jtt.reflect.Field_get03.test(7)) {
22386 fail(runString);
22387 return;
22388 }
22389 // (8) == false
22390 runString = "(8)";
22391 if (false != jtt.reflect.Field_get03.test(8)) {
22392 fail(runString);
22393 return;
22394 }
22395 } catch (Throwable t) {
22396 fail(runString, t);
22397 return;
22398 }
22399 pass();
22400 }
22401
22402 static void jtt_reflect_Field_get04() {
22403 begin("jtt.reflect.Field_get04");
22404 String runString = null;
22405 try {
22406 // (0) == true
22407 runString = "(0)";
22408 if (true != jtt.reflect.Field_get04.test(0)) {
22409 fail(runString);
22410 return;
22411 }
22412 // (1) == true
22413 runString = "(1)";
22414 if (true != jtt.reflect.Field_get04.test(1)) {
22415 fail(runString);
22416 return;
22417 }
22418 // (2) == true
22419 runString = "(2)";
22420 if (true != jtt.reflect.Field_get04.test(2)) {
22421 fail(runString);
22422 return;
22423 }
22424 // (3) == true
22425 runString = "(3)";
22426 if (true != jtt.reflect.Field_get04.test(3)) {
22427 fail(runString);
22428 return;
22429 }
22430 // (4) == true
22431 runString = "(4)";
22432 if (true != jtt.reflect.Field_get04.test(4)) {
22433 fail(runString);
22434 return;
22435 }
22436 // (5) == true
22437 runString = "(5)";
22438 if (true != jtt.reflect.Field_get04.test(5)) {
22439 fail(runString);
22440 return;
22441 }
22442 // (6) == true
22443 runString = "(6)";
22444 if (true != jtt.reflect.Field_get04.test(6)) {
22445 fail(runString);
22446 return;
22447 }
22448 // (7) == true
22449 runString = "(7)";
22450 if (true != jtt.reflect.Field_get04.test(7)) {
22451 fail(runString);
22452 return;
22453 }
22454 // (8) == false
22455 runString = "(8)";
22456 if (false != jtt.reflect.Field_get04.test(8)) {
22457 fail(runString);
22458 return;
22459 }
22460 } catch (Throwable t) {
22461 fail(runString, t);
22462 return;
22463 }
22464 pass();
22465 }
22466
22467 static void jtt_reflect_Field_getType01() {
22468 begin("jtt.reflect.Field_getType01");
22469 String runString = null;
22470 try {
22471 // (0) == true
22472 runString = "(0)";
22473 if (true != jtt.reflect.Field_getType01.test(0)) {
22474 fail(runString);
22475 return;
22476 }
22477 // (1) == true
22478 runString = "(1)";
22479 if (true != jtt.reflect.Field_getType01.test(1)) {
22480 fail(runString);
22481 return;
22482 }
22483 // (2) == true
22484 runString = "(2)";
22485 if (true != jtt.reflect.Field_getType01.test(2)) {
22486 fail(runString);
22487 return;
22488 }
22489 // (3) == true
22490 runString = "(3)";
22491 if (true != jtt.reflect.Field_getType01.test(3)) {
22492 fail(runString);
22493 return;
22494 }
22495 // (4) == true
22496 runString = "(4)";
22497 if (true != jtt.reflect.Field_getType01.test(4)) {
22498 fail(runString);
22499 return;
22500 }
22501 // (5) == true
22502 runString = "(5)";
22503 if (true != jtt.reflect.Field_getType01.test(5)) {
22504 fail(runString);
22505 return;
22506 }
22507 // (6) == true
22508 runString = "(6)";
22509 if (true != jtt.reflect.Field_getType01.test(6)) {
22510 fail(runString);
22511 return;
22512 }
22513 // (7) == true
22514 runString = "(7)";
22515 if (true != jtt.reflect.Field_getType01.test(7)) {
22516 fail(runString);
22517 return;
22518 }
22519 // (8) == false
22520 runString = "(8)";
22521 if (false != jtt.reflect.Field_getType01.test(8)) {
22522 fail(runString);
22523 return;
22524 }
22525 } catch (Throwable t) {
22526 fail(runString, t);
22527 return;
22528 }
22529 pass();
22530 }
22531
22532 static void jtt_reflect_Field_set01() {
22533 begin("jtt.reflect.Field_set01");
22534 String runString = null;
22535 try {
22536 // (0) == true
22537 runString = "(0)";
22538 if (true != jtt.reflect.Field_set01.test(0)) {
22539 fail(runString);
22540 return;
22541 }
22542 // (1) == true
22543 runString = "(1)";
22544 if (true != jtt.reflect.Field_set01.test(1)) {
22545 fail(runString);
22546 return;
22547 }
22548 // (2) == true
22549 runString = "(2)";
22550 if (true != jtt.reflect.Field_set01.test(2)) {
22551 fail(runString);
22552 return;
22553 }
22554 // (3) == true
22555 runString = "(3)";
22556 if (true != jtt.reflect.Field_set01.test(3)) {
22557 fail(runString);
22558 return;
22559 }
22560 // (4) == true
22561 runString = "(4)";
22562 if (true != jtt.reflect.Field_set01.test(4)) {
22563 fail(runString);
22564 return;
22565 }
22566 // (5) == true
22567 runString = "(5)";
22568 if (true != jtt.reflect.Field_set01.test(5)) {
22569 fail(runString);
22570 return;
22571 }
22572 // (6) == true
22573 runString = "(6)";
22574 if (true != jtt.reflect.Field_set01.test(6)) {
22575 fail(runString);
22576 return;
22577 }
22578 // (7) == true
22579 runString = "(7)";
22580 if (true != jtt.reflect.Field_set01.test(7)) {
22581 fail(runString);
22582 return;
22583 }
22584 // (8) == false
22585 runString = "(8)";
22586 if (false != jtt.reflect.Field_set01.test(8)) {
22587 fail(runString);
22588 return;
22589 }
22590 } catch (Throwable t) {
22591 fail(runString, t);
22592 return;
22593 }
22594 pass();
22595 }
22596
22597 static void jtt_reflect_Field_set02() {
22598 begin("jtt.reflect.Field_set02");
22599 String runString = null;
22600 try {
22601 // (0) == true
22602 runString = "(0)";
22603 if (true != jtt.reflect.Field_set02.test(0)) {
22604 fail(runString);
22605 return;
22606 }
22607 // (1) == true
22608 runString = "(1)";
22609 if (true != jtt.reflect.Field_set02.test(1)) {
22610 fail(runString);
22611 return;
22612 }
22613 // (2) == true
22614 runString = "(2)";
22615 if (true != jtt.reflect.Field_set02.test(2)) {
22616 fail(runString);
22617 return;
22618 }
22619 // (3) == true
22620 runString = "(3)";
22621 if (true != jtt.reflect.Field_set02.test(3)) {
22622 fail(runString);
22623 return;
22624 }
22625 // (4) == true
22626 runString = "(4)";
22627 if (true != jtt.reflect.Field_set02.test(4)) {
22628 fail(runString);
22629 return;
22630 }
22631 // (5) == true
22632 runString = "(5)";
22633 if (true != jtt.reflect.Field_set02.test(5)) {
22634 fail(runString);
22635 return;
22636 }
22637 // (6) == true
22638 runString = "(6)";
22639 if (true != jtt.reflect.Field_set02.test(6)) {
22640 fail(runString);
22641 return;
22642 }
22643 // (7) == true
22644 runString = "(7)";
22645 if (true != jtt.reflect.Field_set02.test(7)) {
22646 fail(runString);
22647 return;
22648 }
22649 // (8) == false
22650 runString = "(8)";
22651 if (false != jtt.reflect.Field_set02.test(8)) {
22652 fail(runString);
22653 return;
22654 }
22655 } catch (Throwable t) {
22656 fail(runString, t);
22657 return;
22658 }
22659 pass();
22660 }
22661
22662 static void jtt_reflect_Field_set03() {
22663 begin("jtt.reflect.Field_set03");
22664 String runString = null;
22665 try {
22666 // (0) == true
22667 runString = "(0)";
22668 if (true != jtt.reflect.Field_set03.test(0)) {
22669 fail(runString);
22670 return;
22671 }
22672 // (1) == true
22673 runString = "(1)";
22674 if (true != jtt.reflect.Field_set03.test(1)) {
22675 fail(runString);
22676 return;
22677 }
22678 // (2) == true
22679 runString = "(2)";
22680 if (true != jtt.reflect.Field_set03.test(2)) {
22681 fail(runString);
22682 return;
22683 }
22684 // (3) == true
22685 runString = "(3)";
22686 if (true != jtt.reflect.Field_set03.test(3)) {
22687 fail(runString);
22688 return;
22689 }
22690 // (4) == true
22691 runString = "(4)";
22692 if (true != jtt.reflect.Field_set03.test(4)) {
22693 fail(runString);
22694 return;
22695 }
22696 // (5) == true
22697 runString = "(5)";
22698 if (true != jtt.reflect.Field_set03.test(5)) {
22699 fail(runString);
22700 return;
22701 }
22702 // (6) == true
22703 runString = "(6)";
22704 if (true != jtt.reflect.Field_set03.test(6)) {
22705 fail(runString);
22706 return;
22707 }
22708 // (7) == true
22709 runString = "(7)";
22710 if (true != jtt.reflect.Field_set03.test(7)) {
22711 fail(runString);
22712 return;
22713 }
22714 // (8) == false
22715 runString = "(8)";
22716 if (false != jtt.reflect.Field_set03.test(8)) {
22717 fail(runString);
22718 return;
22719 }
22720 } catch (Throwable t) {
22721 fail(runString, t);
22722 return;
22723 }
22724 pass();
22725 }
22726
22727 static void jtt_reflect_Invoke_except01() {
22728 begin("jtt.reflect.Invoke_except01");
22729 String runString = null;
22730 try {
22731 // (0) == 0
22732 runString = "(0)";
22733 if (0 != jtt.reflect.Invoke_except01.test(0)) {
22734 fail(runString);
22735 return;
22736 }
22737 // (1) == 3
22738 runString = "(1)";
22739 if (3 != jtt.reflect.Invoke_except01.test(1)) {
22740 fail(runString);
22741 return;
22742 }
22743 // (2) == !java.lang.reflect.InvocationTargetException
22744 try {
22745 runString = "(2)";
22746 jtt.reflect.Invoke_except01.test(2);
22747 fail(runString);
22748 return;
22749 } catch (Throwable e) {
22750 if (e.getClass() != java.lang.reflect.InvocationTargetException.class) {
22751 fail(runString, e);
22752 return;
22753 }
22754 }
22755 // (3) == !java.lang.IllegalArgumentException
22756 try {
22757 runString = "(3)";
22758 jtt.reflect.Invoke_except01.test(3);
22759 fail(runString);
22760 return;
22761 } catch (Throwable e) {
22762 if (e.getClass() != java.lang.IllegalArgumentException.class) {
22763 fail(runString, e);
22764 return;
22765 }
22766 }
22767 // (4) == !java.lang.IllegalArgumentException
22768 try {
22769 runString = "(4)";
22770 jtt.reflect.Invoke_except01.test(4);
22771 fail(runString);
22772 return;
22773 } catch (Throwable e) {
22774 if (e.getClass() != java.lang.IllegalArgumentException.class) {
22775 fail(runString, e);
22776 return;
22777 }
22778 }
22779 } catch (Throwable t) {
22780 fail(runString, t);
22781 return;
22782 }
22783 pass();
22784 }
22785
22786 static void jtt_reflect_Invoke_main01() {
22787 begin("jtt.reflect.Invoke_main01");
22788 String runString = null;
22789 try {
22790 // ("test1") == "test1"
22791 runString = "(\"test1\")";
22792 if (!"test1".equals(jtt.reflect.Invoke_main01.test("test1"))) {
22793 fail(runString);
22794 return;
22795 }
22796 // ("test2") == "test2"
22797 runString = "(\"test2\")";
22798 if (!"test2".equals(jtt.reflect.Invoke_main01.test("test2"))) {
22799 fail(runString);
22800 return;
22801 }
22802 } catch (Throwable t) {
22803 fail(runString, t);
22804 return;
22805 }
22806 pass();
22807 }
22808
22809 static void jtt_reflect_Invoke_main02() {
22810 begin("jtt.reflect.Invoke_main02");
22811 String runString = null;
22812 try {
22813 // ("test1") == "test1"
22814 runString = "(\"test1\")";
22815 if (!"test1".equals(jtt.reflect.Invoke_main02.test("test1"))) {
22816 fail(runString);
22817 return;
22818 }
22819 // ("test2") == "test2"
22820 runString = "(\"test2\")";
22821 if (!"test2".equals(jtt.reflect.Invoke_main02.test("test2"))) {
22822 fail(runString);
22823 return;
22824 }
22825 } catch (Throwable t) {
22826 fail(runString, t);
22827 return;
22828 }
22829 pass();
22830 }
22831
22832 static void jtt_reflect_Invoke_main03() {
22833 begin("jtt.reflect.Invoke_main03");
22834 String runString = null;
22835 try {
22836 // ("test1") == "test1"
22837 runString = "(\"test1\")";
22838 if (!"test1".equals(jtt.reflect.Invoke_main03.test("test1"))) {
22839 fail(runString);
22840 return;
22841 }
22842 // ("test2") == "test2"
22843 runString = "(\"test2\")";
22844 if (!"test2".equals(jtt.reflect.Invoke_main03.test("test2"))) {
22845 fail(runString);
22846 return;
22847 }
22848 } catch (Throwable t) {
22849 fail(runString, t);
22850 return;
22851 }
22852 pass();
22853 }
22854
22855 static void jtt_reflect_Invoke_virtual01() {
22856 begin("jtt.reflect.Invoke_virtual01");
22857 String runString = null;
22858 try {
22859 // (1) == 55
22860 runString = "(1)";
22861 if (55 != jtt.reflect.Invoke_virtual01.test(1)) {
22862 fail(runString);
22863 return;
22864 }
22865 } catch (Throwable t) {
22866 fail(runString, t);
22867 return;
22868 }
22869 pass();
22870 }
22871
22872 static void jtt_reflect_Method_getParameterTypes01() {
22873 begin("jtt.reflect.Method_getParameterTypes01");
22874 String runString = null;
22875 try {
22876 // (0) == 0
22877 runString = "(0)";
22878 if (0 != jtt.reflect.Method_getParameterTypes01.test(0)) {
22879 fail(runString);
22880 return;
22881 }
22882 // (1) == 1
22883 runString = "(1)";
22884 if (1 != jtt.reflect.Method_getParameterTypes01.test(1)) {
22885 fail(runString);
22886 return;
22887 }
22888 // (2) == 2
22889 runString = "(2)";
22890 if (2 != jtt.reflect.Method_getParameterTypes01.test(2)) {
22891 fail(runString);
22892 return;
22893 }
22894 // (3) == -1
22895 runString = "(3)";
22896 if (-1 != jtt.reflect.Method_getParameterTypes01.test(3)) {
22897 fail(runString);
22898 return;
22899 }
22900 } catch (Throwable t) {
22901 fail(runString, t);
22902 return;
22903 }
22904 pass();
22905 }
22906
22907 static void jtt_reflect_Method_getReturnType01() {
22908 begin("jtt.reflect.Method_getReturnType01");
22909 String runString = null;
22910 try {
22911 // (0) == "int"
22912 runString = "(0)";
22913 if (!"int".equals(jtt.reflect.Method_getReturnType01.test(0))) {
22914 fail(runString);
22915 return;
22916 }
22917 // (1) == "java.lang.String"
22918 runString = "(1)";
22919 if (!"java.lang.String".equals(jtt.reflect.Method_getReturnType01
22920 .test(1))) {
22921 fail(runString);
22922 return;
22923 }
22924 // (2) == "void"
22925 runString = "(2)";
22926 if (!"void".equals(jtt.reflect.Method_getReturnType01.test(2))) {
22927 fail(runString);
22928 return;
22929 }
22930 // (3) == null
22931 runString = "(3)";
22932 if (null != jtt.reflect.Method_getReturnType01.test(3)) {
22933 fail(runString);
22934 return;
22935 }
22936 } catch (Throwable t) {
22937 fail(runString, t);
22938 return;
22939 }
22940 pass();
22941 }
22942
22943 static void jtt_reflect_Reflection_getCallerClass01() {
22944 begin("jtt.reflect.Reflection_getCallerClass01");
22945 String runString = null;
22946 try {
22947 // (0) == "sun.reflect.Reflection"
22948 runString = "(0)";
22949 if (!"sun.reflect.Reflection"
22950 .equals(jtt.reflect.Reflection_getCallerClass01.test(0))) {
22951 fail(runString);
22952 return;
22953 }
22954 // (1) == "jtt.reflect.Reflection_getCallerClass01$Caller1"
22955 runString = "(1)";
22956 if (!"jtt.reflect.Reflection_getCallerClass01$Caller1"
22957 .equals(jtt.reflect.Reflection_getCallerClass01.test(1))) {
22958 fail(runString);
22959 return;
22960 }
22961 // (2) == "jtt.reflect.Reflection_getCallerClass01$Caller2"
22962 runString = "(2)";
22963 if (!"jtt.reflect.Reflection_getCallerClass01$Caller2"
22964 .equals(jtt.reflect.Reflection_getCallerClass01.test(2))) {
22965 fail(runString);
22966 return;
22967 }
22968 } catch (Throwable t) {
22969 fail(runString, t);
22970 return;
22971 }
22972 pass();
22973 }
22974
22975 static void jtt_threads_Monitor_contended01() {
22976 begin("jtt.threads.Monitor_contended01");
22977 String runString = null;
22978 try {
22979 // (0) == true
22980 runString = "(0)";
22981 if (true != jtt.threads.Monitor_contended01.test(0)) {
22982 fail(runString);
22983 return;
22984 }
22985 } catch (Throwable t) {
22986 fail(runString, t);
22987 return;
22988 }
22989 pass();
22990 }
22991
22992 static void jtt_threads_Monitor_notowner01() {
22993 begin("jtt.threads.Monitor_notowner01");
22994 String runString = null;
22995 try {
22996 // (0) == true
22997 runString = "(0)";
22998 if (true != jtt.threads.Monitor_notowner01.test(0)) {
22999 fail(runString);
23000 return;
23001 }
23002 } catch (Throwable t) {
23003 fail(runString, t);
23004 return;
23005 }
23006 pass();
23007 }
23008
23009 static void jtt_threads_Monitorenter01() {
23010 begin("jtt.threads.Monitorenter01");
23011 String runString = null;
23012 try {
23013 // (0) == true
23014 runString = "(0)";
23015 if (true != jtt.threads.Monitorenter01.test(0)) {
23016 fail(runString);
23017 return;
23018 }
23019 } catch (Throwable t) {
23020 fail(runString, t);
23021 return;
23022 }
23023 pass();
23024 }
23025
23026 static void jtt_threads_Monitorenter02() {
23027 begin("jtt.threads.Monitorenter02");
23028 String runString = null;
23029 try {
23030 // (0) == true
23031 runString = "(0)";
23032 if (true != jtt.threads.Monitorenter02.test(0)) {
23033 fail(runString);
23034 return;
23035 }
23036 } catch (Throwable t) {
23037 fail(runString, t);
23038 return;
23039 }
23040 pass();
23041 }
23042
23043 static void jtt_threads_Object_wait01() {
23044 begin("jtt.threads.Object_wait01");
23045 String runString = null;
23046 try {
23047 // (0) == true
23048 runString = "(0)";
23049 if (true != jtt.threads.Object_wait01.test(0)) {
23050 fail(runString);
23051 return;
23052 }
23053 // (1) == true
23054 runString = "(1)";
23055 if (true != jtt.threads.Object_wait01.test(1)) {
23056 fail(runString);
23057 return;
23058 }
23059 // (3) == true
23060 runString = "(3)";
23061 if (true != jtt.threads.Object_wait01.test(3)) {
23062 fail(runString);
23063 return;
23064 }
23065 // (15) == true
23066 runString = "(15)";
23067 if (true != jtt.threads.Object_wait01.test(15)) {
23068 fail(runString);
23069 return;
23070 }
23071 } catch (Throwable t) {
23072 fail(runString, t);
23073 return;
23074 }
23075 pass();
23076 }
23077
23078 static void jtt_threads_Object_wait02() {
23079 begin("jtt.threads.Object_wait02");
23080 String runString = null;
23081 try {
23082 // (0) == true
23083 runString = "(0)";
23084 if (true != jtt.threads.Object_wait02.test(0)) {
23085 fail(runString);
23086 return;
23087 }
23088 // (1) == true
23089 runString = "(1)";
23090 if (true != jtt.threads.Object_wait02.test(1)) {
23091 fail(runString);
23092 return;
23093 }
23094 // (2) == true
23095 runString = "(2)";
23096 if (true != jtt.threads.Object_wait02.test(2)) {
23097 fail(runString);
23098 return;
23099 }
23100 } catch (Throwable t) {
23101 fail(runString, t);
23102 return;
23103 }
23104 pass();
23105 }
23106
23107 static void jtt_threads_Object_wait03() {
23108 begin("jtt.threads.Object_wait03");
23109 String runString = null;
23110 try {
23111 // (0) == true
23112 runString = "(0)";
23113 if (true != jtt.threads.Object_wait03.test(0)) {
23114 fail(runString);
23115 return;
23116 }
23117 // (1) == true
23118 runString = "(1)";
23119 if (true != jtt.threads.Object_wait03.test(1)) {
23120 fail(runString);
23121 return;
23122 }
23123 // (2) == true
23124 runString = "(2)";
23125 if (true != jtt.threads.Object_wait03.test(2)) {
23126 fail(runString);
23127 return;
23128 }
23129 } catch (Throwable t) {
23130 fail(runString, t);
23131 return;
23132 }
23133 pass();
23134 }
23135
23136 static void jtt_threads_Object_wait04() {
23137 begin("jtt.threads.Object_wait04");
23138 String runString = null;
23139 try {
23140 // (0) == true
23141 runString = "(0)";
23142 if (true != jtt.threads.Object_wait04.test(0)) {
23143 fail(runString);
23144 return;
23145 }
23146 // (1) == true
23147 runString = "(1)";
23148 if (true != jtt.threads.Object_wait04.test(1)) {
23149 fail(runString);
23150 return;
23151 }
23152 // (2) == true
23153 runString = "(2)";
23154 if (true != jtt.threads.Object_wait04.test(2)) {
23155 fail(runString);
23156 return;
23157 }
23158 // (3) == true
23159 runString = "(3)";
23160 if (true != jtt.threads.Object_wait04.test(3)) {
23161 fail(runString);
23162 return;
23163 }
23164 // (4) == true
23165 runString = "(4)";
23166 if (true != jtt.threads.Object_wait04.test(4)) {
23167 fail(runString);
23168 return;
23169 }
23170 // (5) == true
23171 runString = "(5)";
23172 if (true != jtt.threads.Object_wait04.test(5)) {
23173 fail(runString);
23174 return;
23175 }
23176 } catch (Throwable t) {
23177 fail(runString, t);
23178 return;
23179 }
23180 pass();
23181 }
23182
23183 static void jtt_threads_ThreadLocal01() {
23184 begin("jtt.threads.ThreadLocal01");
23185 String runString = null;
23186 try {
23187 // (0) == 5
23188 runString = "(0)";
23189 if (5 != jtt.threads.ThreadLocal01.test(0)) {
23190 fail(runString);
23191 return;
23192 }
23193 // (1) == 6
23194 runString = "(1)";
23195 if (6 != jtt.threads.ThreadLocal01.test(1)) {
23196 fail(runString);
23197 return;
23198 }
23199 // (2) == 7
23200 runString = "(2)";
23201 if (7 != jtt.threads.ThreadLocal01.test(2)) {
23202 fail(runString);
23203 return;
23204 }
23205 } catch (Throwable t) {
23206 fail(runString, t);
23207 return;
23208 }
23209 pass();
23210 }
23211
23212 static void jtt_threads_ThreadLocal02() {
23213 begin("jtt.threads.ThreadLocal02");
23214 String runString = null;
23215 try {
23216 // (0) == 5
23217 runString = "(0)";
23218 if (5 != jtt.threads.ThreadLocal02.test(0)) {
23219 fail(runString);
23220 return;
23221 }
23222 // (1) == 6
23223 runString = "(1)";
23224 if (6 != jtt.threads.ThreadLocal02.test(1)) {
23225 fail(runString);
23226 return;
23227 }
23228 // (2) == 7
23229 runString = "(2)";
23230 if (7 != jtt.threads.ThreadLocal02.test(2)) {
23231 fail(runString);
23232 return;
23233 }
23234 } catch (Throwable t) {
23235 fail(runString, t);
23236 return;
23237 }
23238 pass();
23239 }
23240
23241 static void jtt_threads_ThreadLocal03() {
23242 begin("jtt.threads.ThreadLocal03");
23243 String runString = null;
23244 try {
23245 // (0) == 0
23246 runString = "(0)";
23247 if (0 != jtt.threads.ThreadLocal03.test(0)) {
23248 fail(runString);
23249 return;
23250 }
23251 // (1) == 15
23252 runString = "(1)";
23253 if (15 != jtt.threads.ThreadLocal03.test(1)) {
23254 fail(runString);
23255 return;
23256 }
23257 // (2) == 31
23258 runString = "(2)";
23259 if (31 != jtt.threads.ThreadLocal03.test(2)) {
23260 fail(runString);
23261 return;
23262 }
23263 // (3) == 48
23264 runString = "(3)";
23265 if (48 != jtt.threads.ThreadLocal03.test(3)) {
23266 fail(runString);
23267 return;
23268 }
23269 } catch (Throwable t) {
23270 fail(runString, t);
23271 return;
23272 }
23273 pass();
23274 }
23275
23276 static void jtt_threads_Thread_currentThread01() {
23277 begin("jtt.threads.Thread_currentThread01");
23278 String runString = null;
23279 try {
23280 // (0) == true
23281 runString = "(0)";
23282 if (true != jtt.threads.Thread_currentThread01.test(0)) {
23283 fail(runString);
23284 return;
23285 }
23286 } catch (Throwable t) {
23287 fail(runString, t);
23288 return;
23289 }
23290 pass();
23291 }
23292
23293 static void jtt_threads_Thread_getState01() {
23294 begin("jtt.threads.Thread_getState01");
23295 String runString = null;
23296 try {
23297 // (0) == true
23298 runString = "(0)";
23299 if (true != jtt.threads.Thread_getState01.test(0)) {
23300 fail(runString);
23301 return;
23302 }
23303 } catch (Throwable t) {
23304 fail(runString, t);
23305 return;
23306 }
23307 pass();
23308 }
23309
23310 static void jtt_threads_Thread_getState02() {
23311 begin("jtt.threads.Thread_getState02");
23312 String runString = null;
23313 try {
23314 // (0) == true
23315 runString = "(0)";
23316 if (true != jtt.threads.Thread_getState02.test(0)) {
23317 fail(runString);
23318 return;
23319 }
23320 } catch (Throwable t) {
23321 fail(runString, t);
23322 return;
23323 }
23324 pass();
23325 }
23326
23327 static void jtt_threads_Thread_holdsLock01() {
23328 begin("jtt.threads.Thread_holdsLock01");
23329 String runString = null;
23330 try {
23331 // (0) == true
23332 runString = "(0)";
23333 if (true != jtt.threads.Thread_holdsLock01.test(0)) {
23334 fail(runString);
23335 return;
23336 }
23337 // (1) == false
23338 runString = "(1)";
23339 if (false != jtt.threads.Thread_holdsLock01.test(1)) {
23340 fail(runString);
23341 return;
23342 }
23343 // (2) == !java.lang.NullPointerException
23344 try {
23345 runString = "(2)";
23346 jtt.threads.Thread_holdsLock01.test(2);
23347 fail(runString);
23348 return;
23349 } catch (Throwable e) {
23350 if (e.getClass() != java.lang.NullPointerException.class) {
23351 fail(runString, e);
23352 return;
23353 }
23354 }
23355 // (3) == false
23356 runString = "(3)";
23357 if (false != jtt.threads.Thread_holdsLock01.test(3)) {
23358 fail(runString);
23359 return;
23360 }
23361 } catch (Throwable t) {
23362 fail(runString, t);
23363 return;
23364 }
23365 pass();
23366 }
23367
23368 static void jtt_threads_Thread_isAlive01() {
23369 begin("jtt.threads.Thread_isAlive01");
23370 String runString = null;
23371 try {
23372 // (0) == true
23373 runString = "(0)";
23374 if (true != jtt.threads.Thread_isAlive01.test(0)) {
23375 fail(runString);
23376 return;
23377 }
23378 } catch (Throwable t) {
23379 fail(runString, t);
23380 return;
23381 }
23382 pass();
23383 }
23384
23385 static void jtt_threads_Thread_isInterrupted01() {
23386 begin("jtt.threads.Thread_isInterrupted01");
23387 String runString = null;
23388 try {
23389 // (0) == false
23390 runString = "(0)";
23391 if (false != jtt.threads.Thread_isInterrupted01.test(0)) {
23392 fail(runString);
23393 return;
23394 }
23395 } catch (Throwable t) {
23396 fail(runString, t);
23397 return;
23398 }
23399 pass();
23400 }
23401
23402 static void jtt_threads_Thread_isInterrupted02() {
23403 begin("jtt.threads.Thread_isInterrupted02");
23404 String runString = null;
23405 try {
23406 // (0,0) == true
23407 runString = "(0,0)";
23408 if (true != jtt.threads.Thread_isInterrupted02.test(0, 0)) {
23409 fail(runString);
23410 return;
23411 }
23412 // (1,500) == true
23413 runString = "(1,500)";
23414 if (true != jtt.threads.Thread_isInterrupted02.test(1, 500)) {
23415 fail(runString);
23416 return;
23417 }
23418 } catch (Throwable t) {
23419 fail(runString, t);
23420 return;
23421 }
23422 pass();
23423 }
23424
23425 static void jtt_threads_Thread_isInterrupted03() {
23426 begin("jtt.threads.Thread_isInterrupted03");
23427 String runString = null;
23428 try {
23429 // (0) == true
23430 runString = "(0)";
23431 if (true != jtt.threads.Thread_isInterrupted03.test(0)) {
23432 fail(runString);
23433 return;
23434 }
23435 } catch (Throwable t) {
23436 fail(runString, t);
23437 return;
23438 }
23439 pass();
23440 }
23441
23442 static void jtt_threads_Thread_isInterrupted04() {
23443 begin("jtt.threads.Thread_isInterrupted04");
23444 String runString = null;
23445 try {
23446 // (0) == true
23447 runString = "(0)";
23448 if (true != jtt.threads.Thread_isInterrupted04.test(0)) {
23449 fail(runString);
23450 return;
23451 }
23452 } catch (Throwable t) {
23453 fail(runString, t);
23454 return;
23455 }
23456 pass();
23457 }
23458
23459 static void jtt_threads_Thread_isInterrupted05() {
23460 begin("jtt.threads.Thread_isInterrupted05");
23461 String runString = null;
23462 try {
23463 // (0) == true
23464 runString = "(0)";
23465 if (true != jtt.threads.Thread_isInterrupted05.test(0)) {
23466 fail(runString);
23467 return;
23468 }
23469 } catch (Throwable t) {
23470 fail(runString, t);
23471 return;
23472 }
23473 pass();
23474 }
23475
23476 static void jtt_threads_Thread_join01() {
23477 begin("jtt.threads.Thread_join01");
23478 String runString = null;
23479 try {
23480 // (0) == false
23481 runString = "(0)";
23482 if (false != jtt.threads.Thread_join01.test(0)) {
23483 fail(runString);
23484 return;
23485 }
23486 } catch (Throwable t) {
23487 fail(runString, t);
23488 return;
23489 }
23490 pass();
23491 }
23492
23493 static void jtt_threads_Thread_join02() {
23494 begin("jtt.threads.Thread_join02");
23495 String runString = null;
23496 try {
23497 // (0) == false
23498 runString = "(0)";
23499 if (false != jtt.threads.Thread_join02.test(0)) {
23500 fail(runString);
23501 return;
23502 }
23503 } catch (Throwable t) {
23504 fail(runString, t);
23505 return;
23506 }
23507 pass();
23508 }
23509
23510 static void jtt_threads_Thread_join03() {
23511 begin("jtt.threads.Thread_join03");
23512 String runString = null;
23513 try {
23514 // (0) == false
23515 runString = "(0)";
23516 if (false != jtt.threads.Thread_join03.test(0)) {
23517 fail(runString);
23518 return;
23519 }
23520 } catch (Throwable t) {
23521 fail(runString, t);
23522 return;
23523 }
23524 pass();
23525 }
23526
23527 static void jtt_threads_Thread_new01() {
23528 begin("jtt.threads.Thread_new01");
23529 String runString = null;
23530 try {
23531 // (0) == true
23532 runString = "(0)";
23533 if (true != jtt.threads.Thread_new01.test(0)) {
23534 fail(runString);
23535 return;
23536 }
23537 // (1) == true
23538 runString = "(1)";
23539 if (true != jtt.threads.Thread_new01.test(1)) {
23540 fail(runString);
23541 return;
23542 }
23543 // (2) == true
23544 runString = "(2)";
23545 if (true != jtt.threads.Thread_new01.test(2)) {
23546 fail(runString);
23547 return;
23548 }
23549 // (3) == true
23550 runString = "(3)";
23551 if (true != jtt.threads.Thread_new01.test(3)) {
23552 fail(runString);
23553 return;
23554 }
23555 // (4) == false
23556 runString = "(4)";
23557 if (false != jtt.threads.Thread_new01.test(4)) {
23558 fail(runString);
23559 return;
23560 }
23561 } catch (Throwable t) {
23562 fail(runString, t);
23563 return;
23564 }
23565 pass();
23566 }
23567
23568 static void jtt_threads_Thread_new02() {
23569 begin("jtt.threads.Thread_new02");
23570 String runString = null;
23571 try {
23572 // (0) == true
23573 runString = "(0)";
23574 if (true != jtt.threads.Thread_new02.test(0)) {
23575 fail(runString);
23576 return;
23577 }
23578 // (1) == true
23579 runString = "(1)";
23580 if (true != jtt.threads.Thread_new02.test(1)) {
23581 fail(runString);
23582 return;
23583 }
23584 // (2) == true
23585 runString = "(2)";
23586 if (true != jtt.threads.Thread_new02.test(2)) {
23587 fail(runString);
23588 return;
23589 }
23590 // (3) == true
23591 runString = "(3)";
23592 if (true != jtt.threads.Thread_new02.test(3)) {
23593 fail(runString);
23594 return;
23595 }
23596 // (4) == false
23597 runString = "(4)";
23598 if (false != jtt.threads.Thread_new02.test(4)) {
23599 fail(runString);
23600 return;
23601 }
23602 } catch (Throwable t) {
23603 fail(runString, t);
23604 return;
23605 }
23606 pass();
23607 }
23608
23609 static void jtt_threads_Thread_setPriority01() {
23610 begin("jtt.threads.Thread_setPriority01");
23611 String runString = null;
23612 try {
23613 // (0) == !java.lang.IllegalArgumentException
23614 try {
23615 runString = "(0)";
23616 jtt.threads.Thread_setPriority01.test(0);
23617 fail(runString);
23618 return;
23619 } catch (Throwable e) {
23620 if (e.getClass() != java.lang.IllegalArgumentException.class) {
23621 fail(runString, e);
23622 return;
23623 }
23624 }
23625 // (1) == true
23626 runString = "(1)";
23627 if (true != jtt.threads.Thread_setPriority01.test(1)) {
23628 fail(runString);
23629 return;
23630 }
23631 // (5) == true
23632 runString = "(5)";
23633 if (true != jtt.threads.Thread_setPriority01.test(5)) {
23634 fail(runString);
23635 return;
23636 }
23637 // (10) == true
23638 runString = "(10)";
23639 if (true != jtt.threads.Thread_setPriority01.test(10)) {
23640 fail(runString);
23641 return;
23642 }
23643 // (11) == !java.lang.IllegalArgumentException
23644 try {
23645 runString = "(11)";
23646 jtt.threads.Thread_setPriority01.test(11);
23647 fail(runString);
23648 return;
23649 } catch (Throwable e) {
23650 if (e.getClass() != java.lang.IllegalArgumentException.class) {
23651 fail(runString, e);
23652 return;
23653 }
23654 }
23655 } catch (Throwable t) {
23656 fail(runString, t);
23657 return;
23658 }
23659 pass();
23660 }
23661
23662 static void jtt_threads_Thread_sleep01() {
23663 begin("jtt.threads.Thread_sleep01");
23664 String runString = null;
23665 try {
23666 // (10) == true
23667 runString = "(10)";
23668 if (true != jtt.threads.Thread_sleep01.test(10)) {
23669 fail(runString);
23670 return;
23671 }
23672 // (20) == true
23673 runString = "(20)";
23674 if (true != jtt.threads.Thread_sleep01.test(20)) {
23675 fail(runString);
23676 return;
23677 }
23678 // (100) == true
23679 runString = "(100)";
23680 if (true != jtt.threads.Thread_sleep01.test(100)) {
23681 fail(runString);
23682 return;
23683 }
23684 } catch (Throwable t) {
23685 fail(runString, t);
23686 return;
23687 }
23688 pass();
23689 }
23690
23691 static void jtt_threads_Thread_start01() {
23692 begin("jtt.threads.Thread_start01");
23693 String runString = null;
23694 try {
23695 // (0) == true
23696 runString = "(0)";
23697 if (true != jtt.threads.Thread_start01.test(0)) {
23698 fail(runString);
23699 return;
23700 }
23701 } catch (Throwable t) {
23702 fail(runString, t);
23703 return;
23704 }
23705 pass();
23706 }
23707
23708 static void jtt_threads_Thread_yield01() {
23709 begin("jtt.threads.Thread_yield01");
23710 String runString = null;
23711 try {
23712 // (0) == true
23713 runString = "(0)";
23714 if (true != jtt.threads.Thread_yield01.test(0)) {
23715 fail(runString);
23716 return;
23717 }
23718 } catch (Throwable t) {
23719 fail(runString, t);
23720 return;
23721 }
23722 pass();
23723 }
23724
23725 static void jtt_jdk_Class_getName() {
23726 begin("jtt.jdk.Class_getName");
23727 String runString = null;
23728 try {
23729 // (0) == "java.lang.String"
23730 runString = "(0)";
23731 if (!"java.lang.String".equals(jtt.jdk.Class_getName.test(0))) {
23732 fail(runString);
23733 return;
23734 }
23735 } catch (Throwable t) {
23736 fail(runString, t);
23737 return;
23738 }
23739 pass();
23740 }
23741
23742 static void jtt_jdk_EnumMap01() {
23743 begin("jtt.jdk.EnumMap01");
23744 String runString = null;
23745 try {
23746 // (0) == "A"
23747 runString = "(0)";
23748 if (!"A".equals(jtt.jdk.EnumMap01.test(0))) {
23749 fail(runString);
23750 return;
23751 }
23752 } catch (Throwable t) {
23753 fail(runString, t);
23754 return;
23755 }
23756 pass();
23757 }
23758
23759 static void jtt_jdk_EnumMap02() {
23760 begin("jtt.jdk.EnumMap02");
23761 String runString = null;
23762 try {
23763 // (0) == "A"
23764 runString = "(0)";
23765 if (!"A".equals(jtt.jdk.EnumMap02.test(0))) {
23766 fail(runString);
23767 return;
23768 }
23769 } catch (Throwable t) {
23770 fail(runString, t);
23771 return;
23772 }
23773 pass();
23774 }
23775
23776 static void jtt_jdk_System_currentTimeMillis01() {
23777 begin("jtt.jdk.System_currentTimeMillis01");
23778 String runString = null;
23779 try {
23780 // (0) == 1
23781 runString = "(0)";
23782 if (1 != jtt.jdk.System_currentTimeMillis01.test(0)) {
23783 fail(runString);
23784 return;
23785 }
23786 } catch (Throwable t) {
23787 fail(runString, t);
23788 return;
23789 }
23790 pass();
23791 }
23792
23793 static void jtt_jdk_System_currentTimeMillis02() {
23794 begin("jtt.jdk.System_currentTimeMillis02");
23795 String runString = null;
23796 try {
23797 // (0) == true
23798 runString = "(0)";
23799 if (true != jtt.jdk.System_currentTimeMillis02.test(0)) {
23800 fail(runString);
23801 return;
23802 }
23803 } catch (Throwable t) {
23804 fail(runString, t);
23805 return;
23806 }
23807 pass();
23808 }
23809
23810 static void jtt_jdk_System_nanoTime01() {
23811 begin("jtt.jdk.System_nanoTime01");
23812 String runString = null;
23813 try {
23814 // (0) == 1
23815 runString = "(0)";
23816 if (1 != jtt.jdk.System_nanoTime01.test(0)) {
23817 fail(runString);
23818 return;
23819 }
23820 } catch (Throwable t) {
23821 fail(runString, t);
23822 return;
23823 }
23824 pass();
23825 }
23826
23827 static void jtt_jdk_System_nanoTime02() {
23828 begin("jtt.jdk.System_nanoTime02");
23829 String runString = null;
23830 try {
23831 // (0) == true
23832 runString = "(0)";
23833 if (true != jtt.jdk.System_nanoTime02.test(0)) {
23834 fail(runString);
23835 return;
23836 }
23837 } catch (Throwable t) {
23838 fail(runString, t);
23839 return;
23840 }
23841 pass();
23842 }
23843
23844 static void jtt_jdk_UnsafeAccess01() {
23845 begin("jtt.jdk.UnsafeAccess01");
23846 String runString = null;
23847 try {
23848 // (0) == 42
23849 runString = "(0)";
23850 if (42 != jtt.jdk.UnsafeAccess01.test(0)) {
23851 fail(runString);
23852 return;
23853 }
23854 } catch (Throwable t) {
23855 fail(runString, t);
23856 return;
23857 }
23858 pass();
23859 }
23860
23861 static void jtt_micro_ReferenceMap01() {
23862 begin("jtt.micro.ReferenceMap01");
23863 String runString = null;
23864 try {
23865 // (0) == 7878
23866 runString = "(0)";
23867 if (7878 != jtt.micro.ReferenceMap01.test(0)) {
23868 fail(runString);
23869 return;
23870 }
23871 } catch (Throwable t) {
23872 fail(runString, t);
23873 return;
23874 }
23875 pass();
23876 }
23877 // END GENERATED TEST RUNS
23878 // Checkstyle: resume
23879
23880 }