Mercurial > hg > graal-jvmci-8
comparison test/compiler/6934604/TestDoubleBoxing.java @ 10278:6f3fd5150b67
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 TestDoubleBoxing | |
29 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:+EliminateAutoBox | |
30 * -XX:CompileCommand=exclude,TestDoubleBoxing.dummy -XX:CompileCommand=exclude,TestDoubleBoxing.foo -XX:CompileCommand=exclude,TestDoubleBoxing.foob TestDoubleBoxing | |
31 * @run main/othervm -Xbatch -XX:+IgnoreUnrecognizedVMOptions -XX:-EliminateAutoBox | |
32 * -XX:CompileCommand=exclude,TestDoubleBoxing.dummy -XX:CompileCommand=exclude,TestDoubleBoxing.foo -XX:CompileCommand=exclude,TestDoubleBoxing.foob TestDoubleBoxing | |
33 * | |
34 */ | |
35 | |
36 public class TestDoubleBoxing { | |
37 | |
38 static final Double ibc = new Double(1.); | |
39 | |
40 //=============================================== | |
41 // Non-inlined methods to test deoptimization info | |
42 static void dummy() { } | |
43 static double foo(double i) { return i; } | |
44 static Double foob(double i) { return Double.valueOf(i); } | |
45 | |
46 | |
47 static double simple(double i) { | |
48 Double ib = new Double(i); | |
49 return ib; | |
50 } | |
51 | |
52 static double simpleb(double i) { | |
53 Double ib = Double.valueOf(i); | |
54 return ib; | |
55 } | |
56 | |
57 static double simplec() { | |
58 Double ib = ibc; | |
59 return ib; | |
60 } | |
61 | |
62 static double simplef(double i) { | |
63 Double ib = foob(i); | |
64 return ib; | |
65 } | |
66 | |
67 static double simplep(Double ib) { | |
68 return ib; | |
69 } | |
70 | |
71 static double simple2(double i) { | |
72 Double ib1 = new Double(i); | |
73 Double ib2 = new Double(i+1.); | |
74 return ib1 + ib2; | |
75 } | |
76 | |
77 static double simpleb2(double i) { | |
78 Double ib1 = Double.valueOf(i); | |
79 Double ib2 = Double.valueOf(i+1.); | |
80 return ib1 + ib2; | |
81 } | |
82 | |
83 static double simplem2(double i) { | |
84 Double ib1 = new Double(i); | |
85 Double ib2 = Double.valueOf(i+1.); | |
86 return ib1 + ib2; | |
87 } | |
88 | |
89 static double simplep2(double i, Double ib1) { | |
90 Double ib2 = Double.valueOf(i+1.); | |
91 return ib1 + ib2; | |
92 } | |
93 | |
94 static double simplec2(double i) { | |
95 Double ib1 = ibc; | |
96 Double ib2 = Double.valueOf(i+1.); | |
97 return ib1 + ib2; | |
98 } | |
99 | |
100 //=============================================== | |
101 static double test(double f, int i) { | |
102 Double ib = new Double(f); | |
103 if ((i&1) == 0) | |
104 ib = f+1.; | |
105 return ib; | |
106 } | |
107 | |
108 static double testb(double f, int i) { | |
109 Double ib = f; | |
110 if ((i&1) == 0) | |
111 ib = (f+1.); | |
112 return ib; | |
113 } | |
114 | |
115 static double testm(double f, int i) { | |
116 Double ib = f; | |
117 if ((i&1) == 0) | |
118 ib = new Double(f+1.); | |
119 return ib; | |
120 } | |
121 | |
122 static double testp(double f, int i, Double ib) { | |
123 if ((i&1) == 0) | |
124 ib = new Double(f+1.); | |
125 return ib; | |
126 } | |
127 | |
128 static double testc(double f, int i) { | |
129 Double ib = ibc; | |
130 if ((i&1) == 0) | |
131 ib = new Double(f+1.); | |
132 return ib; | |
133 } | |
134 | |
135 static double test2(double f, int i) { | |
136 Double ib1 = new Double(f); | |
137 Double ib2 = new Double(f+1.); | |
138 if ((i&1) == 0) { | |
139 ib1 = new Double(f+1.); | |
140 ib2 = new Double(f+2.); | |
141 } | |
142 return ib1+ib2; | |
143 } | |
144 | |
145 static double testb2(double f, int i) { | |
146 Double ib1 = f; | |
147 Double ib2 = f+1.; | |
148 if ((i&1) == 0) { | |
149 ib1 = (f+1.); | |
150 ib2 = (f+2.); | |
151 } | |
152 return ib1+ib2; | |
153 } | |
154 | |
155 static double testm2(double f, int i) { | |
156 Double ib1 = new Double(f); | |
157 Double ib2 = f+1.; | |
158 if ((i&1) == 0) { | |
159 ib1 = new Double(f+1.); | |
160 ib2 = (f+2.); | |
161 } | |
162 return ib1+ib2; | |
163 } | |
164 | |
165 static double testp2(double f, int i, Double ib1) { | |
166 Double ib2 = f+1.; | |
167 if ((i&1) == 0) { | |
168 ib1 = new Double(f+1.); | |
169 ib2 = (f+2.); | |
170 } | |
171 return ib1+ib2; | |
172 } | |
173 | |
174 static double testc2(double f, int i) { | |
175 Double ib1 = ibc; | |
176 Double ib2 = f+1.; | |
177 if ((i&1) == 0) { | |
178 ib1 = (ibc+1.); | |
179 ib2 = (f+2.); | |
180 } | |
181 return ib1+ib2; | |
182 } | |
183 | |
184 //=============================================== | |
185 static double sum(double[] a) { | |
186 double result = 1.; | |
187 for (Double i : a) | |
188 result += i; | |
189 return result; | |
190 } | |
191 | |
192 static double sumb(double[] a) { | |
193 Double result = 1.; | |
194 for (Double i : a) | |
195 result += i; | |
196 return result; | |
197 } | |
198 | |
199 static double sumc(double[] a) { | |
200 Double result = ibc; | |
201 for (Double i : a) | |
202 result += i; | |
203 return result; | |
204 } | |
205 | |
206 static double sumf(double[] a) { | |
207 Double result = foob(1.); | |
208 for (Double i : a) | |
209 result += i; | |
210 return result; | |
211 } | |
212 | |
213 static double sump(double[] a, Double result) { | |
214 for (Double i : a) | |
215 result += i; | |
216 return result; | |
217 } | |
218 | |
219 static double sum2(double[] a) { | |
220 double result1 = 1.; | |
221 double result2 = 1.; | |
222 for (Double i : a) { | |
223 result1 += i; | |
224 result2 += i + 1.; | |
225 } | |
226 return result1 + result2; | |
227 } | |
228 | |
229 static double sumb2(double[] a) { | |
230 Double result1 = 1.; | |
231 Double result2 = 1.; | |
232 for (Double i : a) { | |
233 result1 += i; | |
234 result2 += i + 1.; | |
235 } | |
236 return result1 + result2; | |
237 } | |
238 | |
239 static double summ2(double[] a) { | |
240 Double result1 = 1.; | |
241 Double result2 = new Double(1.); | |
242 for (Double i : a) { | |
243 result1 += i; | |
244 result2 += new Double(i + 1.); | |
245 } | |
246 return result1 + result2; | |
247 } | |
248 | |
249 static double sump2(double[] a, Double result2) { | |
250 Double result1 = 1.; | |
251 for (Double i : a) { | |
252 result1 += i; | |
253 result2 += i + 1.; | |
254 } | |
255 return result1 + result2; | |
256 } | |
257 | |
258 static double sumc2(double[] a) { | |
259 Double result1 = 1.; | |
260 Double result2 = ibc; | |
261 for (Double i : a) { | |
262 result1 += i; | |
263 result2 += i + ibc; | |
264 } | |
265 return result1 + result2; | |
266 } | |
267 | |
268 //=============================================== | |
269 static double remi_sum() { | |
270 Double j = new Double(1.); | |
271 for (int i = 0; i< 1000; i++) { | |
272 j = new Double(j + 1.); | |
273 } | |
274 return j; | |
275 } | |
276 | |
277 static double remi_sumb() { | |
278 Double j = Double.valueOf(1.); | |
279 for (int i = 0; i< 1000; i++) { | |
280 j = j + 1.; | |
281 } | |
282 return j; | |
283 } | |
284 | |
285 static double remi_sumf() { | |
286 Double j = foob(1.); | |
287 for (int i = 0; i< 1000; i++) { | |
288 j = j + 1.; | |
289 } | |
290 return j; | |
291 } | |
292 | |
293 static double remi_sump(Double j) { | |
294 for (int i = 0; i< 1000; i++) { | |
295 j = new Double(j + 1.); | |
296 } | |
297 return j; | |
298 } | |
299 | |
300 static double remi_sumc() { | |
301 Double j = ibc; | |
302 for (int i = 0; i< 1000; i++) { | |
303 j = j + ibc; | |
304 } | |
305 return j; | |
306 } | |
307 | |
308 static double remi_sum2() { | |
309 Double j1 = new Double(1.); | |
310 Double j2 = new Double(1.); | |
311 for (int i = 0; i< 1000; i++) { | |
312 j1 = new Double(j1 + 1.); | |
313 j2 = new Double(j2 + 2.); | |
314 } | |
315 return j1 + j2; | |
316 } | |
317 | |
318 static double remi_sumb2() { | |
319 Double j1 = Double.valueOf(1.); | |
320 Double j2 = Double.valueOf(1.); | |
321 for (int i = 0; i< 1000; i++) { | |
322 j1 = j1 + 1.; | |
323 j2 = j2 + 2.; | |
324 } | |
325 return j1 + j2; | |
326 } | |
327 | |
328 static double remi_summ2() { | |
329 Double j1 = new Double(1.); | |
330 Double j2 = Double.valueOf(1.); | |
331 for (int i = 0; i< 1000; i++) { | |
332 j1 = new Double(j1 + 1.); | |
333 j2 = j2 + 2.; | |
334 } | |
335 return j1 + j2; | |
336 } | |
337 | |
338 static double remi_sump2(Double j1) { | |
339 Double j2 = Double.valueOf(1.); | |
340 for (int i = 0; i< 1000; i++) { | |
341 j1 = new Double(j1 + 1.); | |
342 j2 = j2 + 2.; | |
343 } | |
344 return j1 + j2; | |
345 } | |
346 | |
347 static double remi_sumc2() { | |
348 Double j1 = ibc; | |
349 Double j2 = Double.valueOf(1.); | |
350 for (int i = 0; i< 1000; i++) { | |
351 j1 = j1 + ibc; | |
352 j2 = j2 + 2.; | |
353 } | |
354 return j1 + j2; | |
355 } | |
356 | |
357 | |
358 //=============================================== | |
359 // Safepointa and debug info for deoptimization | |
360 static double simple_deop(double i) { | |
361 Double ib = new Double(foo(i)); | |
362 dummy(); | |
363 return ib; | |
364 } | |
365 | |
366 static double simpleb_deop(double i) { | |
367 Double ib = Double.valueOf(foo(i)); | |
368 dummy(); | |
369 return ib; | |
370 } | |
371 | |
372 static double simplef_deop(double i) { | |
373 Double ib = foob(i); | |
374 dummy(); | |
375 return ib; | |
376 } | |
377 | |
378 static double simplep_deop(Double ib) { | |
379 dummy(); | |
380 return ib; | |
381 } | |
382 | |
383 static double simplec_deop(double i) { | |
384 Double ib = ibc; | |
385 dummy(); | |
386 return ib; | |
387 } | |
388 | |
389 static double test_deop(double f, int i) { | |
390 Double ib = new Double(foo(f)); | |
391 if ((i&1) == 0) | |
392 ib = foo(f+1.); | |
393 dummy(); | |
394 return ib; | |
395 } | |
396 | |
397 static double testb_deop(double f, int i) { | |
398 Double ib = foo(f); | |
399 if ((i&1) == 0) | |
400 ib = foo(f+1.); | |
401 dummy(); | |
402 return ib; | |
403 } | |
404 | |
405 static double testf_deop(double f, int i) { | |
406 Double ib = foob(f); | |
407 if ((i&1) == 0) | |
408 ib = foo(f+1.); | |
409 dummy(); | |
410 return ib; | |
411 } | |
412 | |
413 static double testp_deop(double f, int i, Double ib) { | |
414 if ((i&1) == 0) | |
415 ib = foo(f+1.); | |
416 dummy(); | |
417 return ib; | |
418 } | |
419 | |
420 static double testc_deop(double f, int i) { | |
421 Double ib = ibc; | |
422 if ((i&1) == 0) | |
423 ib = foo(f+1.); | |
424 dummy(); | |
425 return ib; | |
426 } | |
427 | |
428 static double sum_deop(double[] a) { | |
429 double result = 1.; | |
430 for (Double i : a) | |
431 result += foo(i); | |
432 dummy(); | |
433 return result; | |
434 } | |
435 | |
436 static double sumb_deop(double[] a) { | |
437 Double result = 1.; | |
438 for (Double i : a) | |
439 result += foo(i); | |
440 dummy(); | |
441 return result; | |
442 } | |
443 | |
444 static double sumf_deop(double[] a) { | |
445 Double result = 1.; | |
446 for (Double i : a) | |
447 result += foob(i); | |
448 dummy(); | |
449 return result; | |
450 } | |
451 | |
452 static double sump_deop(double[] a, Double result) { | |
453 for (Double i : a) | |
454 result += foob(i); | |
455 dummy(); | |
456 return result; | |
457 } | |
458 | |
459 static double sumc_deop(double[] a) { | |
460 Double result = ibc; | |
461 for (Double i : a) | |
462 result += foo(i); | |
463 dummy(); | |
464 return result; | |
465 } | |
466 | |
467 static double remi_sum_deop() { | |
468 Double j = new Double(foo(1.)); | |
469 for (int i = 0; i< 1000; i++) { | |
470 j = new Double(foo(j + 1.)); | |
471 } | |
472 dummy(); | |
473 return j; | |
474 } | |
475 | |
476 static double remi_sumb_deop() { | |
477 Double j = Double.valueOf(foo(1.)); | |
478 for (int i = 0; i< 1000; i++) { | |
479 j = foo(j + 1.); | |
480 } | |
481 dummy(); | |
482 return j; | |
483 } | |
484 | |
485 static double remi_sumf_deop() { | |
486 Double j = foob(1.); | |
487 for (int i = 0; i< 1000; i++) { | |
488 j = foo(j + 1.); | |
489 } | |
490 dummy(); | |
491 return j; | |
492 } | |
493 | |
494 static double remi_sump_deop(Double j) { | |
495 for (int i = 0; i< 1000; i++) { | |
496 j = foo(j + 1.); | |
497 } | |
498 dummy(); | |
499 return j; | |
500 } | |
501 | |
502 static double remi_sumc_deop() { | |
503 Double j = ibc; | |
504 for (int i = 0; i< 1000; i++) { | |
505 j = foo(j + 1.); | |
506 } | |
507 dummy(); | |
508 return j; | |
509 } | |
510 | |
511 //=============================================== | |
512 // Conditional increment | |
513 static double remi_sum_cond() { | |
514 Double j = new Double(1.); | |
515 for (int i = 0; i< 1000; i++) { | |
516 if ((i&1) == 0) { | |
517 j = new Double(j + 1.); | |
518 } | |
519 } | |
520 return j; | |
521 } | |
522 | |
523 static double remi_sumb_cond() { | |
524 Double j = Double.valueOf(1.); | |
525 for (int i = 0; i< 1000; i++) { | |
526 if ((i&1) == 0) { | |
527 j = j + 1.; | |
528 } | |
529 } | |
530 return j; | |
531 } | |
532 | |
533 static double remi_sumf_cond() { | |
534 Double j = foob(1.); | |
535 for (int i = 0; i< 1000; i++) { | |
536 if ((i&1) == 0) { | |
537 j = j + 1.; | |
538 } | |
539 } | |
540 return j; | |
541 } | |
542 | |
543 static double remi_sump_cond(Double j) { | |
544 for (int i = 0; i< 1000; i++) { | |
545 if ((i&1) == 0) { | |
546 j = j + 1.; | |
547 } | |
548 } | |
549 return j; | |
550 } | |
551 | |
552 static double remi_sumc_cond() { | |
553 Double j = ibc; | |
554 for (int i = 0; i< 1000; i++) { | |
555 if ((i&1) == 0) { | |
556 j = j + ibc; | |
557 } | |
558 } | |
559 return j; | |
560 } | |
561 | |
562 static double remi_sum2_cond() { | |
563 Double j1 = new Double(1.); | |
564 Double j2 = new Double(1.); | |
565 for (int i = 0; i< 1000; i++) { | |
566 if ((i&1) == 0) { | |
567 j1 = new Double(j1 + 1.); | |
568 } else { | |
569 j2 = new Double(j2 + 2.); | |
570 } | |
571 } | |
572 return j1 + j2; | |
573 } | |
574 | |
575 static double remi_sumb2_cond() { | |
576 Double j1 = Double.valueOf(1.); | |
577 Double j2 = Double.valueOf(1.); | |
578 for (int i = 0; i< 1000; i++) { | |
579 if ((i&1) == 0) { | |
580 j1 = j1 + 1.; | |
581 } else { | |
582 j2 = j2 + 2.; | |
583 } | |
584 } | |
585 return j1 + j2; | |
586 } | |
587 | |
588 static double remi_summ2_cond() { | |
589 Double j1 = new Double(1.); | |
590 Double j2 = Double.valueOf(1.); | |
591 for (int i = 0; i< 1000; i++) { | |
592 if ((i&1) == 0) { | |
593 j1 = new Double(j1 + 1.); | |
594 } else { | |
595 j2 = j2 + 2.; | |
596 } | |
597 } | |
598 return j1 + j2; | |
599 } | |
600 | |
601 static double remi_sump2_cond(Double j1) { | |
602 Double j2 = Double.valueOf(1.); | |
603 for (int i = 0; i< 1000; i++) { | |
604 if ((i&1) == 0) { | |
605 j1 = new Double(j1 + 1.); | |
606 } else { | |
607 j2 = j2 + 2.; | |
608 } | |
609 } | |
610 return j1 + j2; | |
611 } | |
612 | |
613 static double remi_sumc2_cond() { | |
614 Double j1 = ibc; | |
615 Double j2 = Double.valueOf(1.); | |
616 for (int i = 0; i< 1000; i++) { | |
617 if ((i&1) == 0) { | |
618 j1 = j1 + ibc; | |
619 } else { | |
620 j2 = j2 + 2; | |
621 } | |
622 } | |
623 return 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 double[] val = new double[] { | |
648 71994000., 71994000., 12000., 71994000., 71994000., | |
649 144000000., 144000000., 72018000., 144000000., 144000000., | |
650 71994000., 71994000., 12000., 71994000., 71994000., | |
651 72000000., 72000000., 36006000., 72000000., 72000000., | |
652 144012000., 144012000., 72030000., 144012000., 144012000., | |
653 72000000., 72000000., 36006000., 72000000., 72000000., | |
654 499501., 499501., 499501., 499501., 499501., | |
655 1000002., 1000002., 1000002., 1000002., 1000002., | |
656 499501., 499501., 499501., 499501., 499501., | |
657 1001., 1001., 1001., 1001., 1001., | |
658 3002., 3002., 3002., 3002., 3002., | |
659 1001., 1001., 1001., 1001., 1001., | |
660 501., 501., 501., 501., 501., | |
661 1502., 1502., 1502., 1502., 1502. | |
662 }; | |
663 | |
664 double[] res = new double[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(i); | |
672 res[1] += simpleb(i); | |
673 res[2] += simplec(); | |
674 res[3] += simplef(i); | |
675 res[4] += simplep((double)i); | |
676 | |
677 res[5] += simple2((double)i); | |
678 res[6] += simpleb2((double)i); | |
679 res[7] += simplec2((double)i); | |
680 res[8] += simplem2((double)i); | |
681 res[9] += simplep2((double)i, (double)i); | |
682 | |
683 res[10] += simple_deop((double)i); | |
684 res[11] += simpleb_deop((double)i); | |
685 res[12] += simplec_deop((double)i); | |
686 res[13] += simplef_deop((double)i); | |
687 res[14] += simplep_deop((double)i); | |
688 | |
689 res[15] += test((double)i, i); | |
690 res[16] += testb((double)i, i); | |
691 res[17] += testc((double)i, i); | |
692 res[18] += testm((double)i, i); | |
693 res[19] += testp((double)i, i, (double)i); | |
694 | |
695 res[20] += test2((double)i, i); | |
696 res[21] += testb2((double)i, i); | |
697 res[22] += testc2((double)i, i); | |
698 res[23] += testm2((double)i, i); | |
699 res[24] += testp2((double)i, i, (double)i); | |
700 | |
701 res[25] += test_deop((double)i, i); | |
702 res[26] += testb_deop((double)i, i); | |
703 res[27] += testc_deop((double)i, i); | |
704 res[28] += testf_deop((double)i, i); | |
705 res[29] += testp_deop((double)i, i, (double)i); | |
706 } | |
707 | |
708 double[] ia = new double[1000]; | |
709 for (int i = 0; i < 1000; i++) { | |
710 ia[i] = 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, 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, 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, 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(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(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(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(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(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 } |