Mercurial > hg > truffle

comparison test/compiler/6934604/TestByteBoxing.java @ 10278:6f3fd5150b67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6934604: enable parts of EliminateAutoBox by default Summary: Resurrected autobox elimination code and enabled part of it by default. Reviewed-by: roland, twisti
author kvn
date Wed, 08 May 2013 15:08:01 -0700
parents
children
comparison
equal deleted inserted replaced
10277:aabf54ccedb1 10278:6f3fd5150b67
1 /*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @bug 6934604
27 * @summary enable parts of EliminateAutoBox by default
28 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox TestByteBoxing
29 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox
30 * -XX:CompileCommand=exclude,TestByteBoxing.dummy -XX:CompileCommand=exclude,TestByteBoxing.foo -XX:CompileCommand=exclude,TestByteBoxing.foob TestByteBoxing
31 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox
32 * -XX:CompileCommand=exclude,TestByteBoxing.dummy -XX:CompileCommand=exclude,TestByteBoxing.foo -XX:CompileCommand=exclude,TestByteBoxing.foob TestByteBoxing
33 *
34 */
35
36 public class TestByteBoxing {
37
38 static final Byte ibc = new Byte((byte)1);
39
40 //===============================================
41 // Non-inlined methods to test deoptimization info
42 static void dummy() { }
43 static byte foo(byte i) { return i; }
44 static Byte foob(byte i) { return Byte.valueOf(i); }
45
46
47 static byte simple(byte i) {
48 Byte ib = new Byte(i);
49 return ib;
50 }
51
52 static byte simpleb(byte i) {
53 Byte ib = Byte.valueOf(i);
54 return ib;
55 }
56
57 static byte simplec() {
58 Byte ib = ibc;
59 return ib;
60 }
61
62 static byte simplef(byte i) {
63 Byte ib = foob(i);
64 return ib;
65 }
66
67 static byte simplep(Byte ib) {
68 return ib;
69 }
70
71 static byte simple2(byte i) {
72 Byte ib1 = new Byte(i);
73 Byte ib2 = new Byte((byte)(i+1));
74 return (byte)(ib1 + ib2);
75 }
76
77 static byte simpleb2(byte i) {
78 Byte ib1 = Byte.valueOf(i);
79 Byte ib2 = Byte.valueOf((byte)(i+1));
80 return (byte)(ib1 + ib2);
81 }
82
83 static byte simplem2(byte i) {
84 Byte ib1 = new Byte(i);
85 Byte ib2 = Byte.valueOf((byte)(i+1));
86 return (byte)(ib1 + ib2);
87 }
88
89 static byte simplep2(byte i, Byte ib1) {
90 Byte ib2 = Byte.valueOf((byte)(i+1));
91 return (byte)(ib1 + ib2);
92 }
93
94 static byte simplec2(byte i) {
95 Byte ib1 = ibc;
96 Byte ib2 = Byte.valueOf((byte)(i+1));
97 return (byte)(ib1 + ib2);
98 }
99
100 //===============================================
101 static byte test(byte i) {
102 Byte ib = new Byte(i);
103 if ((i&1) == 0)
104 ib = (byte)(i+1);
105 return ib;
106 }
107
108 static byte testb(byte i) {
109 Byte ib = i;
110 if ((i&1) == 0)
111 ib = (byte)(i+1);
112 return ib;
113 }
114
115 static byte testm(byte i) {
116 Byte ib = i;
117 if ((i&1) == 0)
118 ib = new Byte((byte)(i+1));
119 return ib;
120 }
121
122 static byte testp(byte i, Byte ib) {
123 if ((i&1) == 0)
124 ib = new Byte((byte)(i+1));
125 return ib;
126 }
127
128 static byte testc(byte i) {
129 Byte ib = ibc;
130 if ((i&1) == 0)
131 ib = new Byte((byte)(i+1));
132 return ib;
133 }
134
135 static byte test2(byte i) {
136 Byte ib1 = new Byte(i);
137 Byte ib2 = new Byte((byte)(i+1));
138 if ((i&1) == 0) {
139 ib1 = new Byte((byte)(i+1));
140 ib2 = new Byte((byte)(i+2));
141 }
142 return (byte)(ib1+ib2);
143 }
144
145 static byte testb2(byte i) {
146 Byte ib1 = i;
147 Byte ib2 = (byte)(i+1);
148 if ((i&1) == 0) {
149 ib1 = (byte)(i+1);
150 ib2 = (byte)(i+2);
151 }
152 return (byte)(ib1 + ib2);
153 }
154
155 static byte testm2(byte i) {
156 Byte ib1 = new Byte(i);
157 Byte ib2 = (byte)(i+1);
158 if ((i&1) == 0) {
159 ib1 = new Byte((byte)(i+1));
160 ib2 = (byte)(i+2);
161 }
162 return (byte)(ib1 + ib2);
163 }
164
165 static byte testp2(byte i, Byte ib1) {
166 Byte ib2 = (byte)(i+1);
167 if ((i&1) == 0) {
168 ib1 = new Byte((byte)(i+1));
169 ib2 = (byte)(i+2);
170 }
171 return (byte)(ib1 + ib2);
172 }
173
174 static byte testc2(byte i) {
175 Byte ib1 = ibc;
176 Byte ib2 = (byte)(i+1);
177 if ((i&1) == 0) {
178 ib1 = (byte)(ibc+1);
179 ib2 = (byte)(i+2);
180 }
181 return (byte)(ib1 + ib2);
182 }
183
184 //===============================================
185 static byte sum(byte[] a) {
186 byte result = 1;
187 for (Byte i : a)
188 result += i;
189 return result;
190 }
191
192 static byte sumb(byte[] a) {
193 Byte result = 1;
194 for (Byte i : a)
195 result = (byte)(result + i);
196 return result;
197 }
198
199 static byte sumc(byte[] a) {
200 Byte result = ibc;
201 for (Byte i : a)
202 result = (byte)(result + i);
203 return result;
204 }
205
206 static byte sumf(byte[] a) {
207 Byte result = foob((byte)1);
208 for (Byte i : a)
209 result = (byte)(result + i);
210 return result;
211 }
212
213 static byte sump(byte[] a, Byte result) {
214 for (Byte i : a)
215 result = (byte)(result + i);
216 return result;
217 }
218
219 static byte sum2(byte[] a) {
220 byte result1 = 1;
221 byte result2 = 1;
222 for (Byte i : a) {
223 result1 += i;
224 result2 += i + 1;
225 }
226 return (byte)(result1 + result2);
227 }
228
229 static byte sumb2(byte[] a) {
230 Byte result1 = 1;
231 Byte result2 = 1;
232 for (Byte i : a) {
233 result1 = (byte)(result1 + i);
234 result2 = (byte)(result2 + i + 1);
235 }
236 return (byte)(result1 + result2);
237 }
238
239 static byte summ2(byte[] a) {
240 Byte result1 = 1;
241 Byte result2 = new Byte((byte)1);
242 for (Byte i : a) {
243 result1 = (byte)(result1 + i);
244 result2 = (byte)(result2 + new Byte((byte)(i + 1)));
245 }
246 return (byte)(result1 + result2);
247 }
248
249 static byte sump2(byte[] a, Byte result2) {
250 Byte result1 = 1;
251 for (Byte i : a) {
252 result1 = (byte)(result1 + i);
253 result2 = (byte)(result2 + i + 1);
254 }
255 return (byte)(result1 + result2);
256 }
257
258 static byte sumc2(byte[] a) {
259 Byte result1 = 1;
260 Byte result2 = ibc;
261 for (Byte i : a) {
262 result1 = (byte)(result1 + i);
263 result2 = (byte)(result2 + i + ibc);
264 }
265 return (byte)(result1 + result2);
266 }
267
268 //===============================================
269 static byte remi_sum() {
270 Byte j = new Byte((byte)1);
271 for (int i = 0; i< 1000; i++) {
272 j = new Byte((byte)(j + 1));
273 }
274 return j;
275 }
276
277 static byte remi_sumb() {
278 Byte j = Byte.valueOf((byte)1);
279 for (int i = 0; i< 1000; i++) {
280 j = (byte)(j + 1);
281 }
282 return j;
283 }
284
285 static byte remi_sumf() {
286 Byte j = foob((byte)1);
287 for (int i = 0; i< 1000; i++) {
288 j = (byte)(j + 1);
289 }
290 return j;
291 }
292
293 static byte remi_sump(Byte j) {
294 for (int i = 0; i< 1000; i++) {
295 j = new Byte((byte)(j + 1));
296 }
297 return j;
298 }
299
300 static byte remi_sumc() {
301 Byte j = ibc;
302 for (int i = 0; i< 1000; i++) {
303 j = (byte)(j + ibc);
304 }
305 return j;
306 }
307
308 static byte remi_sum2() {
309 Byte j1 = new Byte((byte)1);
310 Byte j2 = new Byte((byte)1);
311 for (int i = 0; i< 1000; i++) {
312 j1 = new Byte((byte)(j1 + 1));
313 j2 = new Byte((byte)(j2 + 2));
314 }
315 return (byte)(j1 + j2);
316 }
317
318 static byte remi_sumb2() {
319 Byte j1 = Byte.valueOf((byte)1);
320 Byte j2 = Byte.valueOf((byte)1);
321 for (int i = 0; i< 1000; i++) {
322 j1 = (byte)(j1 + 1);
323 j2 = (byte)(j2 + 2);
324 }
325 return (byte)(j1 + j2);
326 }
327
328 static byte remi_summ2() {
329 Byte j1 = new Byte((byte)1);
330 Byte j2 = Byte.valueOf((byte)1);
331 for (int i = 0; i< 1000; i++) {
332 j1 = new Byte((byte)(j1 + 1));
333 j2 = (byte)(j2 + 2);
334 }
335 return (byte)(j1 + j2);
336 }
337
338 static byte remi_sump2(Byte j1) {
339 Byte j2 = Byte.valueOf((byte)1);
340 for (int i = 0; i< 1000; i++) {
341 j1 = new Byte((byte)(j1 + 1));
342 j2 = (byte)(j2 + 2);
343 }
344 return (byte)(j1 + j2);
345 }
346
347 static byte remi_sumc2() {
348 Byte j1 = ibc;
349 Byte j2 = Byte.valueOf((byte)1);
350 for (int i = 0; i< 1000; i++) {
351 j1 = (byte)(j1 + ibc);
352 j2 = (byte)(j2 + 2);
353 }
354 return (byte)(j1 + j2);
355 }
356
357
358 //===============================================
359 // Safepointa and debug info for deoptimization
360 static byte simple_deop(byte i) {
361 Byte ib = new Byte(foo(i));
362 dummy();
363 return ib;
364 }
365
366 static byte simpleb_deop(byte i) {
367 Byte ib = Byte.valueOf(foo(i));
368 dummy();
369 return ib;
370 }
371
372 static byte simplef_deop(byte i) {
373 Byte ib = foob(i);
374 dummy();
375 return ib;
376 }
377
378 static byte simplep_deop(Byte ib) {
379 dummy();
380 return ib;
381 }
382
383 static byte simplec_deop(byte i) {
384 Byte ib = ibc;
385 dummy();
386 return ib;
387 }
388
389 static byte test_deop(byte i) {
390 Byte ib = new Byte(foo(i));
391 if ((i&1) == 0)
392 ib = foo((byte)(i+1));
393 dummy();
394 return ib;
395 }
396
397 static byte testb_deop(byte i) {
398 Byte ib = foo(i);
399 if ((i&1) == 0)
400 ib = foo((byte)(i+1));
401 dummy();
402 return ib;
403 }
404
405 static byte testf_deop(byte i) {
406 Byte ib = foob(i);
407 if ((i&1) == 0)
408 ib = foo((byte)(i+1));
409 dummy();
410 return ib;
411 }
412
413 static byte testp_deop(byte i, Byte ib) {
414 if ((i&1) == 0)
415 ib = foo((byte)(i+1));
416 dummy();
417 return ib;
418 }
419
420 static byte testc_deop(byte i) {
421 Byte ib = ibc;
422 if ((i&1) == 0)
423 ib = foo((byte)(i+1));
424 dummy();
425 return ib;
426 }
427
428 static byte sum_deop(byte[] a) {
429 byte result = 1;
430 for (Byte i : a)
431 result += foo(i);
432 dummy();
433 return result;
434 }
435
436 static byte sumb_deop(byte[] a) {
437 Byte result = 1;
438 for (Byte i : a)
439 result = (byte)(result + foo(i));
440 dummy();
441 return result;
442 }
443
444 static byte sumf_deop(byte[] a) {
445 Byte result = 1;
446 for (Byte i : a)
447 result = (byte)(result + foob(i));
448 dummy();
449 return result;
450 }
451
452 static byte sump_deop(byte[] a, Byte result) {
453 for (Byte i : a)
454 result = (byte)(result + foob(i));
455 dummy();
456 return result;
457 }
458
459 static byte sumc_deop(byte[] a) {
460 Byte result = ibc;
461 for (Byte i : a)
462 result = (byte)(result + foo(i));
463 dummy();
464 return result;
465 }
466
467 static byte remi_sum_deop() {
468 Byte j = new Byte(foo((byte)1));
469 for (int i = 0; i< 1000; i++) {
470 j = new Byte(foo((byte)(j + 1)));
471 }
472 dummy();
473 return j;
474 }
475
476 static byte remi_sumb_deop() {
477 Byte j = Byte.valueOf(foo((byte)1));
478 for (int i = 0; i< 1000; i++) {
479 j = foo((byte)(j + 1));
480 }
481 dummy();
482 return j;
483 }
484
485 static byte remi_sumf_deop() {
486 Byte j = foob((byte)1);
487 for (int i = 0; i< 1000; i++) {
488 j = foo((byte)(j + 1));
489 }
490 dummy();
491 return j;
492 }
493
494 static byte remi_sump_deop(Byte j) {
495 for (int i = 0; i< 1000; i++) {
496 j = foo((byte)(j + 1));
497 }
498 dummy();
499 return j;
500 }
501
502 static byte remi_sumc_deop() {
503 Byte j = ibc;
504 for (int i = 0; i< 1000; i++) {
505 j = foo((byte)(j + 1));
506 }
507 dummy();
508 return j;
509 }
510
511 //===============================================
512 // Conditional increment
513 static byte remi_sum_cond() {
514 Byte j = new Byte((byte)1);
515 for (int i = 0; i< 1000; i++) {
516 if ((i&1) == 0) {
517 j = new Byte((byte)(j + 1));
518 }
519 }
520 return j;
521 }
522
523 static byte remi_sumb_cond() {
524 Byte j = Byte.valueOf((byte)1);
525 for (int i = 0; i< 1000; i++) {
526 if ((i&1) == 0) {
527 j = (byte)(j + 1);
528 }
529 }
530 return j;
531 }
532
533 static byte remi_sumf_cond() {
534 Byte j = foob((byte)1);
535 for (int i = 0; i< 1000; i++) {
536 if ((i&1) == 0) {
537 j = (byte)(j + 1);
538 }
539 }
540 return j;
541 }
542
543 static byte remi_sump_cond(Byte j) {
544 for (int i = 0; i< 1000; i++) {
545 if ((i&1) == 0) {
546 j = (byte)(j + 1);
547 }
548 }
549 return j;
550 }
551
552 static byte remi_sumc_cond() {
553 Byte j = ibc;
554 for (int i = 0; i< 1000; i++) {
555 if ((i&1) == 0) {
556 j = (byte)(j + ibc);
557 }
558 }
559 return j;
560 }
561
562 static byte remi_sum2_cond() {
563 Byte j1 = new Byte((byte)1);
564 Byte j2 = new Byte((byte)1);
565 for (int i = 0; i< 1000; i++) {
566 if ((i&1) == 0) {
567 j1 = new Byte((byte)(j1 + 1));
568 } else {
569 j2 = new Byte((byte)(j2 + 2));
570 }
571 }
572 return (byte)(j1 + j2);
573 }
574
575 static byte remi_sumb2_cond() {
576 Byte j1 = Byte.valueOf((byte)1);
577 Byte j2 = Byte.valueOf((byte)1);
578 for (int i = 0; i< 1000; i++) {
579 if ((i&1) == 0) {
580 j1 = (byte)(j1 + 1);
581 } else {
582 j2 = (byte)(j2 + 2);
583 }
584 }
585 return (byte)(j1 + j2);
586 }
587
588 static byte remi_summ2_cond() {
589 Byte j1 = new Byte((byte)1);
590 Byte j2 = Byte.valueOf((byte)1);
591 for (int i = 0; i< 1000; i++) {
592 if ((i&1) == 0) {
593 j1 = new Byte((byte)(j1 + 1));
594 } else {
595 j2 = (byte)(j2 + 2);
596 }
597 }
598 return (byte)(j1 + j2);
599 }
600
601 static byte remi_sump2_cond(Byte j1) {
602 Byte j2 = Byte.valueOf((byte)1);
603 for (int i = 0; i< 1000; i++) {
604 if ((i&1) == 0) {
605 j1 = new Byte((byte)(j1 + 1));
606 } else {
607 j2 = (byte)(j2 + 2);
608 }
609 }
610 return (byte)(j1 + j2);
611 }
612
613 static byte remi_sumc2_cond() {
614 Byte j1 = ibc;
615 Byte j2 = Byte.valueOf((byte)1);
616 for (int i = 0; i< 1000; i++) {
617 if ((i&1) == 0) {
618 j1 = (byte)(j1 + ibc);
619 } else {
620 j2 = (byte)(j2 + 2);
621 }
622 }
623 return (byte)(j1 + j2);
624 }
625
626
627 public static void main(String[] args) {
628 final int ntests = 70;
629
630 String[] test_name = new String[] {
631 "simple", "simpleb", "simplec", "simplef", "simplep",
632 "simple2", "simpleb2", "simplec2", "simplem2", "simplep2",
633 "simple_deop", "simpleb_deop", "simplec_deop", "simplef_deop", "simplep_deop",
634 "test", "testb", "testc", "testm", "testp",
635 "test2", "testb2", "testc2", "testm2", "testp2",
636 "test_deop", "testb_deop", "testc_deop", "testf_deop", "testp_deop",
637 "sum", "sumb", "sumc", "sumf", "sump",
638 "sum2", "sumb2", "sumc2", "summ2", "sump2",
639 "sum_deop", "sumb_deop", "sumc_deop", "sumf_deop", "sump_deop",
640 "remi_sum", "remi_sumb", "remi_sumc", "remi_sumf", "remi_sump",
641 "remi_sum2", "remi_sumb2", "remi_sumc2", "remi_summ2", "remi_sump2",
642 "remi_sum_deop", "remi_sumb_deop", "remi_sumc_deop", "remi_sumf_deop", "remi_sump_deop",
643 "remi_sum_cond", "remi_sumb_cond", "remi_sumc_cond", "remi_sumf_cond", "remi_sump_cond",
644 "remi_sum2_cond", "remi_sumb2_cond", "remi_sumc2_cond", "remi_summ2_cond", "remi_sump2_cond"
645 };
646
647 final int[] val = new int[] {
648 -5488, -5488, 12000, -5488, -5488,
649 1024, 1024, -5552, 1024, 1024,
650 -5488, -5488, 12000, -5488, -5488,
651 512, 512, 6256, 512, 512,
652 13024, 13024, -5584, 13024, 13024,
653 512, 512, 6256, 512, 512,
654 45, 45, 45, 45, 45,
655 66, 66, 66, 66, 66,
656 45, 45, 45, 45, 45,
657 -23, -23, -23, -23, -23,
658 -70, -70, -70, -70, -70,
659 -23, -23, -23, -23, -23,
660 -11, -11, -11, -11, -11,
661 -34, -34, -34, -34, -34
662 };
663
664 int[] res = new int[ntests];
665 for (int i = 0; i < ntests; i++) {
666 res[i] = 0;
667 }
668
669
670 for (int i = 0; i < 12000; i++) {
671 res[0] += simple((byte)i);
672 res[1] += simpleb((byte)i);
673 res[2] += simplec();
674 res[3] += simplef((byte)i);
675 res[4] += simplep((byte)i);
676
677 res[5] += simple2((byte)i);
678 res[6] += simpleb2((byte)i);
679 res[7] += simplec2((byte)i);
680 res[8] += simplem2((byte)i);
681 res[9] += simplep2((byte)i, (byte)i);
682
683 res[10] += simple_deop((byte)i);
684 res[11] += simpleb_deop((byte)i);
685 res[12] += simplec_deop((byte)i);
686 res[13] += simplef_deop((byte)i);
687 res[14] += simplep_deop((byte)i);
688
689 res[15] += test((byte)i);
690 res[16] += testb((byte)i);
691 res[17] += testc((byte)i);
692 res[18] += testm((byte)i);
693 res[19] += testp((byte)i, (byte)i);
694
695 res[20] += test2((byte)i);
696 res[21] += testb2((byte)i);
697 res[22] += testc2((byte)i);
698 res[23] += testm2((byte)i);
699 res[24] += testp2((byte)i, (byte)i);
700
701 res[25] += test_deop((byte)i);
702 res[26] += testb_deop((byte)i);
703 res[27] += testc_deop((byte)i);
704 res[28] += testf_deop((byte)i);
705 res[29] += testp_deop((byte)i, (byte)i);
706 }
707
708 byte[] ia = new byte[1000];
709 for (int i = 0; i < 1000; i++) {
710 ia[i] = (byte)i;
711 }
712
713 for (int i = 0; i < 100; i++) {
714 res[30] = sum(ia);
715 res[31] = sumb(ia);
716 res[32] = sumc(ia);
717 res[33] = sumf(ia);
718 res[34] = sump(ia, (byte)1);
719
720 res[35] = sum2(ia);
721 res[36] = sumb2(ia);
722 res[37] = sumc2(ia);
723 res[38] = summ2(ia);
724 res[39] = sump2(ia, (byte)1);
725
726 res[40] = sum_deop(ia);
727 res[41] = sumb_deop(ia);
728 res[42] = sumc_deop(ia);
729 res[43] = sumf_deop(ia);
730 res[44] = sump_deop(ia, (byte)1);
731
732 res[45] = remi_sum();
733 res[46] = remi_sumb();
734 res[47] = remi_sumc();
735 res[48] = remi_sumf();
736 res[49] = remi_sump((byte)1);
737
738 res[50] = remi_sum2();
739 res[51] = remi_sumb2();
740 res[52] = remi_sumc2();
741 res[53] = remi_summ2();
742 res[54] = remi_sump2((byte)1);
743
744 res[55] = remi_sum_deop();
745 res[56] = remi_sumb_deop();
746 res[57] = remi_sumc_deop();
747 res[58] = remi_sumf_deop();
748 res[59] = remi_sump_deop((byte)1);
749
750 res[60] = remi_sum_cond();
751 res[61] = remi_sumb_cond();
752 res[62] = remi_sumc_cond();
753 res[63] = remi_sumf_cond();
754 res[64] = remi_sump_cond((byte)1);
755
756 res[65] = remi_sum2_cond();
757 res[66] = remi_sumb2_cond();
758 res[67] = remi_sumc2_cond();
759 res[68] = remi_summ2_cond();
760 res[69] = remi_sump2_cond((byte)1);
761 }
762
763 int failed = 0;
764 for (int i = 0; i < ntests; i++) {
765 if (res[i] != val[i]) {
766 System.err.println(test_name[i] + ": " + res[i] + " != " + val[i]);
767 failed++;
768 }
769 }
770 if (failed > 0) {
771 System.err.println("Failed " + failed + " tests.");
772 throw new InternalError();
773 } else {
774 System.out.println("Passed.");
775 }
776 }
777 }