import jdk.testlibrary.TimeLimitedRunner;

    private static final long TIMEOUT = Helper.IS_THOROUGH ? 0L : (long) (Utils.adjustTimeout(Utils.DEFAULT_TEST_TIMEOUT) * 0.9);

        if (gcInfo.size() == 0) {

    private static class TestRun {

        final Function<TestMethods, LambdaFormTestCase> ctor;

        final Collection<TestMethods> testMethods;

        final long totalIterations;

        long doneIterations;

        long testCounter;

        long failCounter;

        boolean passed;

        TestRun(Function<TestMethods, LambdaFormTestCase> ctor, Collection<TestMethods> testMethods) {

            this.ctor = ctor;

            this.testMethods = testMethods;

            long testCaseNum = testMethods.size();

            long iterations = Math.max(1, Helper.TEST_LIMIT / testCaseNum);

            System.out.printf("Number of iterations according to -DtestLimit is %d (%d cases)%n",

                    iterations, iterations * testCaseNum);

            HotSpotDiagnosticMXBean hsDiagBean = ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class);

            long codeCacheSize = Long.parseLong(

                    hsDiagBean.getVMOption("ReservedCodeCacheSize").getValue());

            System.out.printf("Code cache size is %d bytes%n", codeCacheSize);

            long iterationsByCodeCacheSize = (long) (codeCacheSize

                    * ITERATIONS_TO_CODE_CACHE_SIZE_RATIO);

            long nonProfiledCodeCacheSize = Long.parseLong(

                    hsDiagBean.getVMOption("NonProfiledCodeHeapSize").getValue());

            System.out.printf("Non-profiled code cache size is %d bytes%n", nonProfiledCodeCacheSize);

            long iterationsByNonProfiledCodeCacheSize = (long) (nonProfiledCodeCacheSize

                    * ITERATIONS_TO_CODE_CACHE_SIZE_RATIO);

            System.out.printf("Number of iterations limited by code cache size is %d (%d cases)%n",

                    iterationsByCodeCacheSize, iterationsByCodeCacheSize * testCaseNum);

            System.out.printf("Number of iterations limited by non-profiled code cache size is %d (%d cases)%n",

                    iterationsByNonProfiledCodeCacheSize, iterationsByNonProfiledCodeCacheSize * testCaseNum);

            iterations = Math.min(iterationsByCodeCacheSize,

                    Math.min(iterations, iterationsByNonProfiledCodeCacheSize));

            if (iterations == 0) {

                System.out.println("Warning: code cache size is too small to provide at"

                        + " least one iteration! Test will try to do one iteration.");

                iterations = 1;

            }

            System.out.printf("Number of iterations is set to %d (%d cases)%n",

                    iterations, iterations * testCaseNum);

            System.out.flush();

            totalIterations = iterations;

            doneIterations = 0L;

            testCounter = 0L;

            failCounter = 0L;

            passed = true;

        }

        Boolean doIteration() {

            if (doneIterations >= totalIterations) {

                return false;

            }

            System.err.println(String.format("Iteration %d:", doneIterations));

            for (TestMethods testMethod : testMethods) {

                LambdaFormTestCase testCase = ctor.apply(testMethod);

                try {

                    System.err.printf("Tested LF caching feature with MethodHandles.%s method.%n",

                            testCase.getTestMethod().name);

                    testCase.doTest();

                    System.err.println("PASSED");

                } catch (Throwable t) {

                    t.printStackTrace();

                    System.err.printf("FAILED. Caused by %s%n", t.getMessage());

                    passed = false;

                    failCounter++;

                }

                    testCounter++;

                }

            doneIterations++;

            return true;

        }

        void checkPassed() {

            if (!passed) {

                throw new Error(String.format("%d of %d test cases FAILED! %n"

                        + "Rerun the test with the same \"-Dseed=\" option as in the log file!",

                        failCounter, testCounter));

            } else {

                System.err.printf("All %d test cases PASSED!%n", testCounter);

            }

        }

    }

        LambdaFormTestCase.TestRun run =

                new LambdaFormTestCase.TestRun(ctor, testMethods);

        TimeLimitedRunner runner = new TimeLimitedRunner(TIMEOUT, 4.0d, run::doIteration);

        try {

            runner.call();

        } catch (Exception ex) {

            System.err.println("FAILED");

            throw new Error("Unexpected error!", ex);

        run.checkPassed();