52 /** Maximal value for CompLevel */
53 protected static int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
54
55 /** Instance of WhiteBox */
56 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
57 /** Value of {@code -XX:CompileThreshold} */
58 protected static final int COMPILE_THRESHOLD
59 = Integer.parseInt(getVMOption("CompileThreshold", "10000"));
60 /** Value of {@code -XX:BackgroundCompilation} */
61 protected static final boolean BACKGROUND_COMPILATION
62 = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
63 /** Value of {@code -XX:TieredCompilation} */
64 protected static final boolean TIERED_COMPILATION
65 = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
66 /** Value of {@code -XX:TieredStopAtLevel} */
67 protected static final int TIERED_STOP_AT_LEVEL
68 = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));
69 /** Flag for verbose output, true if {@code -Dverbose} specified */
70 protected static final boolean IS_VERBOSE
71 = System.getProperty("verbose") != null;
72 /** count of invocation to triger compilation */
73 protected static final int THRESHOLD;
74 /** count of invocation to triger OSR compilation */
75 protected static final long BACKEDGE_THRESHOLD;
76 /** Value of {@code java.vm.info} (interpreted|mixed|comp mode) */
77 protected static final String MODE = System.getProperty("java.vm.info");
78
79 static {
80 if (TIERED_COMPILATION) {
81 BACKEDGE_THRESHOLD = THRESHOLD = 150000;
82 } else {
83 THRESHOLD = COMPILE_THRESHOLD;
84 BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(
85 "OnStackReplacePercentage"));
86 }
87 }
88
89 /**
90 * Returns value of VM option.
91 *
92 * @param name option's name
93 * @return value of option or {@code null}, if option doesn't exist
94 * @throws NullPointerException if name is null
95 */
199 protected final void checkNotCompiled(int compLevel) {
200 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
201 throw new RuntimeException(method + " must not be in queue");
202 }
203 if (WHITE_BOX.getMethodCompilationLevel(method, false) >= compLevel) {
204 throw new RuntimeException(method + " comp_level must be >= maxCompLevel");
205 }
206 if (WHITE_BOX.getMethodCompilationLevel(method, true) >= compLevel) {
207 throw new RuntimeException(method + " osr_comp_level must be >= maxCompLevel");
208 }
209 }
210
211 /**
212 * Checks, that {@linkplain #method} is not compiled.
213 *
214 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
215 * is compiled, or if {@linkplain #method} has zero
216 * compilation level.
217 */
218 protected final void checkNotCompiled() {
219 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
220 throw new RuntimeException(method + " must not be in queue");
221 }
222 if (WHITE_BOX.isMethodCompiled(method, false)) {
223 throw new RuntimeException(method + " must be not compiled");
224 }
225 if (WHITE_BOX.getMethodCompilationLevel(method, false) != 0) {
226 throw new RuntimeException(method + " comp_level must be == 0");
227 }
228 if (WHITE_BOX.isMethodCompiled(method, true)) {
229 throw new RuntimeException(method + " must be not osr_compiled");
230 }
231 if (WHITE_BOX.getMethodCompilationLevel(method, true) != 0) {
232 throw new RuntimeException(method + " osr_comp_level must be == 0");
233 }
234 }
235
236 /**
237 * Checks, that {@linkplain #method} is compiled.
238 *
239 * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
240 * and isn't compiled, or if {@linkplain #method}
241 * has nonzero compilation level
242 */
243 protected final void checkCompiled() {
244 final long start = System.currentTimeMillis();
245 waitBackgroundCompilation();
246 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
247 System.err.printf("Warning: %s is still in queue after %dms%n",
278 }
279
280 protected final boolean isCompilable(int compLevel) {
281 return WHITE_BOX
282 .isMethodCompilable(method, compLevel, testCase.isOsr());
283 }
284
285 protected final void makeNotCompilable() {
286 WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
287 testCase.isOsr());
288 }
289
290 protected final void makeNotCompilable(int compLevel) {
291 WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
292 }
293
294 /**
295 * Waits for completion of background compilation of {@linkplain #method}.
296 */
297 protected final void waitBackgroundCompilation() {
298 if (!BACKGROUND_COMPILATION) {
299 return;
300 }
301 final Object obj = new Object();
302 for (int i = 0; i < 10
303 && WHITE_BOX.isMethodQueuedForCompilation(method); ++i) {
304 synchronized (obj) {
305 try {
306 obj.wait(1000);
307 } catch (InterruptedException e) {
308 Thread.currentThread().interrupt();
309 }
310 }
311 }
312 }
313
314 /**
315 * Prints information about {@linkplain #method}.
316 */
317 protected final void printInfo() {
318 System.out.printf("%n%s:%n", method);
319 System.out.printf("\tcompilable:\t%b%n",
320 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));
321 System.out.printf("\tcompiled:\t%b%n",
322 WHITE_BOX.isMethodCompiled(method, false));
323 System.out.printf("\tcomp_level:\t%d%n",
397
398 /**
399 * @return {@code true} if the current test case is OSR and the mode is
400 * Xcomp, otherwise {@code false}
401 */
402 protected boolean skipXcompOSR() {
403 boolean result = testCase.isOsr()
404 && CompilerWhiteBoxTest.MODE.startsWith("compiled ");
405 if (result && IS_VERBOSE) {
406 System.err.printf("Warning: %s is not applicable in %s%n",
407 testCase.name(), CompilerWhiteBoxTest.MODE);
408 }
409 return result;
410 }
411 }
412
413 enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
414 /** constructor test case */
415 CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
416 /** method test case */
417 METOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
418 /** static method test case */
419 STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
420 /** OSR constructor test case */
421 OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
422 Helper.OSR_CONSTRUCTOR_CALLABLE, true),
423 /** OSR method test case */
424 OSR_METOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
425 /** OSR static method test case */
426 OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
427
428 private final Executable executable;
429 private final Callable<Integer> callable;
430 private final boolean isOsr;
431
432 private SimpleTestCase(Executable executable, Callable<Integer> callable,
433 boolean isOsr) {
434 this.executable = executable;
435 this.callable = callable;
436 this.isOsr = isOsr;
437 }
438
439 @Override
440 public Executable getExecutable() {
441 return executable;
442 }
443
444 @Override
466 private final Helper helper = new Helper();
467
468 @Override
469 public Integer call() throws Exception {
470 return helper.method();
471 }
472 };
473
474 private static final Callable<Integer> STATIC_CALLABLE
475 = new Callable<Integer>() {
476 @Override
477 public Integer call() throws Exception {
478 return staticMethod();
479 }
480 };
481
482 private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE
483 = new Callable<Integer>() {
484 @Override
485 public Integer call() throws Exception {
486 return new Helper(null).hashCode();
487 }
488 };
489
490 private static final Callable<Integer> OSR_METHOD_CALLABLE
491 = new Callable<Integer>() {
492 private final Helper helper = new Helper();
493
494 @Override
495 public Integer call() throws Exception {
496 return helper.osrMethod();
497 }
498 };
499
500 private static final Callable<Integer> OSR_STATIC_CALLABLE
501 = new Callable<Integer>() {
502 @Override
503 public Integer call() throws Exception {
504 return osrStaticMethod();
505 }
506 };
507
508 private static final Constructor CONSTRUCTOR;
509 private static final Constructor OSR_CONSTRUCTOR;
510 private static final Method METHOD;
511 private static final Method STATIC;
512 private static final Method OSR_METHOD;
513 private static final Method OSR_STATIC;
514
515 static {
516 try {
517 CONSTRUCTOR = Helper.class.getDeclaredConstructor(int.class);
518 } catch (NoSuchMethodException | SecurityException e) {
519 throw new RuntimeException(
520 "exception on getting method Helper.<init>(int)", e);
521 }
522 try {
523 OSR_CONSTRUCTOR = Helper.class.getDeclaredConstructor(
524 Object.class);
525 } catch (NoSuchMethodException | SecurityException e) {
526 throw new RuntimeException(
527 "exception on getting method Helper.<init>(Object)", e);
528 }
529 METHOD = getMethod("method");
530 STATIC = getMethod("staticMethod");
531 OSR_METHOD = getMethod("osrMethod");
532 OSR_STATIC = getMethod("osrStaticMethod");
533 }
534
535 private static Method getMethod(String name) {
536 try {
537 return Helper.class.getDeclaredMethod(name);
538 } catch (NoSuchMethodException | SecurityException e) {
539 throw new RuntimeException(
540 "exception on getting method Helper." + name, e);
541 }
542
543 }
544
545 private static int staticMethod() {
546 return 1138;
547 }
548
549 private int method() {
550 return 42;
551 }
552
553 private static int osrStaticMethod() {
554 int result = 0;
555 for (long i = 0; i < CompilerWhiteBoxTest.BACKEDGE_THRESHOLD; ++i) {
556 result += staticMethod();
557 }
558 return result;
559 }
560
561 private int osrMethod() {
562 int result = 0;
563 for (long i = 0; i < CompilerWhiteBoxTest.BACKEDGE_THRESHOLD; ++i) {
564 result += method();
565 }
566 return result;
567 }
568
569 private final int x;
570
571 // for method and OSR method test case
572 public Helper() {
573 x = 0;
574 }
575
576 // for OSR constructor test case
577 private Helper(Object o) {
578 int result = 0;
579 for (long i = 0; i < CompilerWhiteBoxTest.BACKEDGE_THRESHOLD; ++i) {
580 result += method();
581 }
582 x = result;
583 }
584
585 // for constructor test case
586 private Helper(int x) {
587 this.x = x;
588 }
589
590 @Override
591 public int hashCode() {
592 return x;
593 }
594 }
595 }
|
52 /** Maximal value for CompLevel */
53 protected static int COMP_LEVEL_MAX = COMP_LEVEL_FULL_OPTIMIZATION;
54
55 /** Instance of WhiteBox */
56 protected static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox();
57 /** Value of {@code -XX:CompileThreshold} */
58 protected static final int COMPILE_THRESHOLD
59 = Integer.parseInt(getVMOption("CompileThreshold", "10000"));
60 /** Value of {@code -XX:BackgroundCompilation} */
61 protected static final boolean BACKGROUND_COMPILATION
62 = Boolean.valueOf(getVMOption("BackgroundCompilation", "true"));
63 /** Value of {@code -XX:TieredCompilation} */
64 protected static final boolean TIERED_COMPILATION
65 = Boolean.valueOf(getVMOption("TieredCompilation", "false"));
66 /** Value of {@code -XX:TieredStopAtLevel} */
67 protected static final int TIERED_STOP_AT_LEVEL
68 = Integer.parseInt(getVMOption("TieredStopAtLevel", "0"));
69 /** Flag for verbose output, true if {@code -Dverbose} specified */
70 protected static final boolean IS_VERBOSE
71 = System.getProperty("verbose") != null;
72 /** invocation count to trigger compilation */
73 protected static final int THRESHOLD;
74 /** invocation count to trigger OSR compilation */
75 protected static final long BACKEDGE_THRESHOLD;
76 /** invocation count to warm up method before triggering OSR compilation */
77 protected static final long OSR_WARMUP = 2000;
78 /** Value of {@code java.vm.info} (interpreted|mixed|comp mode) */
79 protected static final String MODE = System.getProperty("java.vm.info");
80
81 static {
82 if (TIERED_COMPILATION) {
83 BACKEDGE_THRESHOLD = THRESHOLD = 150000;
84 } else {
85 THRESHOLD = COMPILE_THRESHOLD;
86 BACKEDGE_THRESHOLD = COMPILE_THRESHOLD * Long.parseLong(getVMOption(
87 "OnStackReplacePercentage"));
88 }
89 }
90
91 /**
92 * Returns value of VM option.
93 *
94 * @param name option's name
95 * @return value of option or {@code null}, if option doesn't exist
96 * @throws NullPointerException if name is null
97 */
201 protected final void checkNotCompiled(int compLevel) {
202 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
203 throw new RuntimeException(method + " must not be in queue");
204 }
205 if (WHITE_BOX.getMethodCompilationLevel(method, false) >= compLevel) {
206 throw new RuntimeException(method + " comp_level must be >= maxCompLevel");
207 }
208 if (WHITE_BOX.getMethodCompilationLevel(method, true) >= compLevel) {
209 throw new RuntimeException(method + " osr_comp_level must be >= maxCompLevel");
210 }
211 }
212
213 /**
214 * Checks, that {@linkplain #method} is not compiled.
215 *
216 * @throws RuntimeException if {@linkplain #method} is in compiler queue or
217 * is compiled, or if {@linkplain #method} has zero
218 * compilation level.
219 */
220 protected final void checkNotCompiled() {
221 if (WHITE_BOX.isMethodCompiled(method, false)) {
222 throw new RuntimeException(method + " must be not compiled");
223 }
224 if (WHITE_BOX.getMethodCompilationLevel(method, false) != 0) {
225 throw new RuntimeException(method + " comp_level must be == 0");
226 }
227 checkNotOsrCompiled();
228 }
229
230 protected final void checkNotOsrCompiled() {
231 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
232 throw new RuntimeException(method + " must not be in queue");
233 }
234 if (WHITE_BOX.isMethodCompiled(method, true)) {
235 throw new RuntimeException(method + " must be not osr_compiled");
236 }
237 if (WHITE_BOX.getMethodCompilationLevel(method, true) != 0) {
238 throw new RuntimeException(method + " osr_comp_level must be == 0");
239 }
240 }
241
242 /**
243 * Checks, that {@linkplain #method} is compiled.
244 *
245 * @throws RuntimeException if {@linkplain #method} isn't in compiler queue
246 * and isn't compiled, or if {@linkplain #method}
247 * has nonzero compilation level
248 */
249 protected final void checkCompiled() {
250 final long start = System.currentTimeMillis();
251 waitBackgroundCompilation();
252 if (WHITE_BOX.isMethodQueuedForCompilation(method)) {
253 System.err.printf("Warning: %s is still in queue after %dms%n",
284 }
285
286 protected final boolean isCompilable(int compLevel) {
287 return WHITE_BOX
288 .isMethodCompilable(method, compLevel, testCase.isOsr());
289 }
290
291 protected final void makeNotCompilable() {
292 WHITE_BOX.makeMethodNotCompilable(method, COMP_LEVEL_ANY,
293 testCase.isOsr());
294 }
295
296 protected final void makeNotCompilable(int compLevel) {
297 WHITE_BOX.makeMethodNotCompilable(method, compLevel, testCase.isOsr());
298 }
299
300 /**
301 * Waits for completion of background compilation of {@linkplain #method}.
302 */
303 protected final void waitBackgroundCompilation() {
304 waitBackgroundCompilation(method);
305 }
306
307 /**
308 * Waits for completion of background compilation of the given executable.
309 *
310 * @param executable Executable
311 */
312 protected static final void waitBackgroundCompilation(Executable executable) {
313 if (!BACKGROUND_COMPILATION) {
314 return;
315 }
316 final Object obj = new Object();
317 for (int i = 0; i < 10
318 && WHITE_BOX.isMethodQueuedForCompilation(executable); ++i) {
319 synchronized (obj) {
320 try {
321 obj.wait(1000);
322 } catch (InterruptedException e) {
323 Thread.currentThread().interrupt();
324 }
325 }
326 }
327 }
328
329 /**
330 * Prints information about {@linkplain #method}.
331 */
332 protected final void printInfo() {
333 System.out.printf("%n%s:%n", method);
334 System.out.printf("\tcompilable:\t%b%n",
335 WHITE_BOX.isMethodCompilable(method, COMP_LEVEL_ANY, false));
336 System.out.printf("\tcompiled:\t%b%n",
337 WHITE_BOX.isMethodCompiled(method, false));
338 System.out.printf("\tcomp_level:\t%d%n",
412
413 /**
414 * @return {@code true} if the current test case is OSR and the mode is
415 * Xcomp, otherwise {@code false}
416 */
417 protected boolean skipXcompOSR() {
418 boolean result = testCase.isOsr()
419 && CompilerWhiteBoxTest.MODE.startsWith("compiled ");
420 if (result && IS_VERBOSE) {
421 System.err.printf("Warning: %s is not applicable in %s%n",
422 testCase.name(), CompilerWhiteBoxTest.MODE);
423 }
424 return result;
425 }
426 }
427
428 enum SimpleTestCase implements CompilerWhiteBoxTest.TestCase {
429 /** constructor test case */
430 CONSTRUCTOR_TEST(Helper.CONSTRUCTOR, Helper.CONSTRUCTOR_CALLABLE, false),
431 /** method test case */
432 METHOD_TEST(Helper.METHOD, Helper.METHOD_CALLABLE, false),
433 /** static method test case */
434 STATIC_TEST(Helper.STATIC, Helper.STATIC_CALLABLE, false),
435 /** OSR constructor test case */
436 OSR_CONSTRUCTOR_TEST(Helper.OSR_CONSTRUCTOR,
437 Helper.OSR_CONSTRUCTOR_CALLABLE, true),
438 /** OSR method test case */
439 OSR_METHOD_TEST(Helper.OSR_METHOD, Helper.OSR_METHOD_CALLABLE, true),
440 /** OSR static method test case */
441 OSR_STATIC_TEST(Helper.OSR_STATIC, Helper.OSR_STATIC_CALLABLE, true);
442
443 private final Executable executable;
444 private final Callable<Integer> callable;
445 private final boolean isOsr;
446
447 private SimpleTestCase(Executable executable, Callable<Integer> callable,
448 boolean isOsr) {
449 this.executable = executable;
450 this.callable = callable;
451 this.isOsr = isOsr;
452 }
453
454 @Override
455 public Executable getExecutable() {
456 return executable;
457 }
458
459 @Override
481 private final Helper helper = new Helper();
482
483 @Override
484 public Integer call() throws Exception {
485 return helper.method();
486 }
487 };
488
489 private static final Callable<Integer> STATIC_CALLABLE
490 = new Callable<Integer>() {
491 @Override
492 public Integer call() throws Exception {
493 return staticMethod();
494 }
495 };
496
497 private static final Callable<Integer> OSR_CONSTRUCTOR_CALLABLE
498 = new Callable<Integer>() {
499 @Override
500 public Integer call() throws Exception {
501 int result = warmup(OSR_CONSTRUCTOR);
502 return result + new Helper(null, CompilerWhiteBoxTest.BACKEDGE_THRESHOLD).hashCode();
503 }
504 };
505
506 private static final Callable<Integer> OSR_METHOD_CALLABLE
507 = new Callable<Integer>() {
508 private final Helper helper = new Helper();
509
510 @Override
511 public Integer call() throws Exception {
512 int result = warmup(OSR_METHOD);
513 return result + helper.osrMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
514 }
515 };
516
517 private static final Callable<Integer> OSR_STATIC_CALLABLE
518 = new Callable<Integer>() {
519 @Override
520 public Integer call() throws Exception {
521 int result = warmup(OSR_STATIC);
522 return result + osrStaticMethod(CompilerWhiteBoxTest.BACKEDGE_THRESHOLD);
523 }
524 };
525
526 /**
527 * Deoptimizes all non-osr versions of the given executable after
528 * compilation finished.
529 *
530 * @param e Executable
531 * @throws Exception
532 */
533 private static void waitAndDeoptimize(Executable e) throws Exception {
534 CompilerWhiteBoxTest.waitBackgroundCompilation(e);
535 if (WhiteBox.getWhiteBox().isMethodQueuedForCompilation(e)) {
536 throw new RuntimeException(e + " must not be in queue");
537 }
538 // Deoptimize non-osr versions of executable
539 WhiteBox.getWhiteBox().deoptimizeMethod(e, false);
540 }
541
542 /**
543 * Executes the method multiple times to make sure we have
544 * enough profiling information before triggering an OSR
545 * compilation. Otherwise the C2 compiler may add uncommon traps.
546 *
547 * @param m Method to be executed
548 * @return Number of times the method was executed
549 * @throws Exception
550 */
551 private static int warmup(Method m) throws Exception {
552 Helper helper = new Helper();
553 int result = 0;
554 for (long i = 0; i < CompilerWhiteBoxTest.OSR_WARMUP; ++i) {
555 result += (int)m.invoke(helper, 1);
556 }
557 // Deoptimize non-osr versions
558 waitAndDeoptimize(m);
559 return result;
560 }
561
562 /**
563 * Executes the constructor multiple times to make sure we
564 * have enough profiling information before triggering an OSR
565 * compilation. Otherwise the C2 compiler may add uncommon traps.
566 *
567 * @param c Constructor to be executed
568 * @return Number of times the constructor was executed
569 * @throws Exception
570 */
571 private static int warmup(Constructor c) throws Exception {
572 int result = 0;
573 for (long i = 0; i < CompilerWhiteBoxTest.OSR_WARMUP; ++i) {
574 result += c.newInstance(null, 1).hashCode();
575 }
576 // Deoptimize non-osr versions
577 waitAndDeoptimize(c);
578 return result;
579 }
580
581 private static final Constructor CONSTRUCTOR;
582 private static final Constructor OSR_CONSTRUCTOR;
583 private static final Method METHOD;
584 private static final Method STATIC;
585 private static final Method OSR_METHOD;
586 private static final Method OSR_STATIC;
587
588 static {
589 try {
590 CONSTRUCTOR = Helper.class.getDeclaredConstructor(int.class);
591 } catch (NoSuchMethodException | SecurityException e) {
592 throw new RuntimeException(
593 "exception on getting method Helper.<init>(int)", e);
594 }
595 try {
596 OSR_CONSTRUCTOR = Helper.class.getDeclaredConstructor(
597 Object.class, long.class);
598 } catch (NoSuchMethodException | SecurityException e) {
599 throw new RuntimeException(
600 "exception on getting method Helper.<init>(Object, long)", e);
601 }
602 METHOD = getMethod("method");
603 STATIC = getMethod("staticMethod");
604 OSR_METHOD = getMethod("osrMethod", long.class);
605 OSR_STATIC = getMethod("osrStaticMethod", long.class);
606 }
607
608 private static Method getMethod(String name, Class<?>... parameterTypes) {
609 try {
610 return Helper.class.getDeclaredMethod(name, parameterTypes);
611 } catch (NoSuchMethodException | SecurityException e) {
612 throw new RuntimeException(
613 "exception on getting method Helper." + name, e);
614 }
615 }
616
617 private static int staticMethod() {
618 return 1138;
619 }
620
621 private int method() {
622 return 42;
623 }
624
625 private static int osrStaticMethod(long limit) {
626 int result = 0;
627 for (long i = 0; i < limit; ++i) {
628 result += staticMethod();
629 }
630 return result;
631 }
632
633 private int osrMethod(long limit) {
634 int result = 0;
635 for (long i = 0; i < limit; ++i) {
636 result += method();
637 }
638 return result;
639 }
640
641 private final int x;
642
643 // for method and OSR method test case
644 public Helper() {
645 x = 0;
646 }
647
648 // for OSR constructor test case
649 private Helper(Object o, long limit) {
650 int result = 0;
651 for (long i = 0; i < limit; ++i) {
652 result += method();
653 }
654 x = result;
655 }
656
657 // for constructor test case
658 private Helper(int x) {
659 this.x = x;
660 }
661
662 @Override
663 public int hashCode() {
664 return x;
665 }
666 }
667 }
|