/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea and Martin Buchholz with assistance from

 * members of JCP JSR-166 Expert Group and released to the public

 * domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 * Other contributors include Andrew Wright, Jeffrey Hayes,

 * Pat Fisher, Mike Judd.

 */

/*

 * @test

 * @summary JSR-166 tck tests, in a number of variations.

 *          The first is the conformance testing variant,

 *          while others also test implementation details.

 * @build *

 * @modules java.management

 * @run junit/othervm/timeout=1000 JSR166TestCase

 * @run junit/othervm/timeout=1000

 *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED

 *      --add-opens java.base/java.lang=ALL-UNNAMED

 *      -Djsr166.testImplementationDetails=true

 *      JSR166TestCase

 * @run junit/othervm/timeout=1000

 *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED

 *      --add-opens java.base/java.lang=ALL-UNNAMED

 *      -Djsr166.testImplementationDetails=true

 *      -Djava.util.concurrent.ForkJoinPool.common.parallelism=0

 *      JSR166TestCase

 * @run junit/othervm/timeout=1000

 *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED

 *      --add-opens java.base/java.lang=ALL-UNNAMED

 *      -Djsr166.testImplementationDetails=true

 *      -Djava.util.concurrent.ForkJoinPool.common.parallelism=1

 *      -Djava.util.secureRandomSeed=true

 *      JSR166TestCase

 * @run junit/othervm/timeout=1000/policy=tck.policy

 *      --add-opens java.base/java.util.concurrent=ALL-UNNAMED

 *      --add-opens java.base/java.lang=ALL-UNNAMED

 *      -Djsr166.testImplementationDetails=true

 *      JSR166TestCase

 */

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import static java.util.concurrent.TimeUnit.MINUTES;

import static java.util.concurrent.TimeUnit.NANOSECONDS;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.lang.management.ManagementFactory;

import java.lang.management.ThreadInfo;

import java.lang.management.ThreadMXBean;

import java.lang.reflect.Constructor;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.security.CodeSource;

import java.security.Permission;

import java.security.PermissionCollection;

import java.security.Permissions;

import java.security.Policy;

import java.security.ProtectionDomain;

import java.security.SecurityPermission;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.Date;

import java.util.Enumeration;

import java.util.Iterator;

import java.util.List;

import java.util.NoSuchElementException;

import java.util.PropertyPermission;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.Executor;

import java.util.concurrent.Executors;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Future;

import java.util.concurrent.FutureTask;

import java.util.concurrent.RecursiveAction;

import java.util.concurrent.RecursiveTask;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.Semaphore;

import java.util.concurrent.ScheduledExecutorService;

import java.util.concurrent.ScheduledFuture;

import java.util.concurrent.SynchronousQueue;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadLocalRandom;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.TimeoutException;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicReference;

import java.util.regex.Pattern;

import junit.framework.AssertionFailedError;

import junit.framework.Test;

import junit.framework.TestCase;

import junit.framework.TestResult;

import junit.framework.TestSuite;

/**

 * Base class for JSR166 Junit TCK tests.  Defines some constants,

 * utility methods and classes, as well as a simple framework for

 * helping to make sure that assertions failing in generated threads

 * cause the associated test that generated them to itself fail (which

 * JUnit does not otherwise arrange).  The rules for creating such

 * tests are:

 *

 * <ol>

 *

 * <li>All assertions in code running in generated threads must use

 * the forms {@link #threadFail}, {@link #threadAssertTrue}, {@link

 * #threadAssertEquals}, or {@link #threadAssertNull}, (not

 * {@code fail}, {@code assertTrue}, etc.) It is OK (but not

 * particularly recommended) for other code to use these forms too.

 * Only the most typically used JUnit assertion methods are defined

 * this way, but enough to live with.

 *

 * <li>If you override {@link #setUp} or {@link #tearDown}, make sure

 * to invoke {@code super.setUp} and {@code super.tearDown} within

 * them. These methods are used to clear and check for thread

 * assertion failures.

 *

 * <li>All delays and timeouts must use one of the constants {@code

 * SHORT_DELAY_MS}, {@code SMALL_DELAY_MS}, {@code MEDIUM_DELAY_MS},

 * {@code LONG_DELAY_MS}. The idea here is that a SHORT is always

 * discriminable from zero time, and always allows enough time for the

 * small amounts of computation (creating a thread, calling a few

 * methods, etc) needed to reach a timeout point. Similarly, a SMALL

 * is always discriminable as larger than SHORT and smaller than

 * MEDIUM.  And so on. These constants are set to conservative values,

 * but even so, if there is ever any doubt, they can all be increased

 * in one spot to rerun tests on slower platforms.

 *

 * <li>All threads generated must be joined inside each test case

 * method (or {@code fail} to do so) before returning from the

 * method. The {@code joinPool} method can be used to do this when

 * using Executors.

 *

 * </ol>

 *

 * <p><b>Other notes</b>

 * <ul>

 *

 * <li>Usually, there is one testcase method per JSR166 method

 * covering "normal" operation, and then as many exception-testing

 * methods as there are exceptions the method can throw. Sometimes

 * there are multiple tests per JSR166 method when the different

 * "normal" behaviors differ significantly. And sometimes testcases

 * cover multiple methods when they cannot be tested in isolation.

 *

 * <li>The documentation style for testcases is to provide as javadoc

 * a simple sentence or two describing the property that the testcase

 * method purports to test. The javadocs do not say anything about how

 * the property is tested. To find out, read the code.

 *

 * <li>These tests are "conformance tests", and do not attempt to

 * test throughput, latency, scalability or other performance factors

 * (see the separate "jtreg" tests for a set intended to check these

 * for the most central aspects of functionality.) So, most tests use

 * the smallest sensible numbers of threads, collection sizes, etc

 * needed to check basic conformance.

 *

 * <li>The test classes currently do not declare inclusion in

 * any particular package to simplify things for people integrating

 * them in TCK test suites.

 *

 * <li>As a convenience, the {@code main} of this class (JSR166TestCase)

 * runs all JSR166 unit tests.

 *

 * </ul>

 */

public class JSR166TestCase extends TestCase {

    private static final boolean useSecurityManager =

        Boolean.getBoolean("jsr166.useSecurityManager");

    protected static final boolean expensiveTests =

        Boolean.getBoolean("jsr166.expensiveTests");

    /**

     * If true, also run tests that are not part of the official tck

     * because they test unspecified implementation details.

     */

    protected static final boolean testImplementationDetails =

        Boolean.getBoolean("jsr166.testImplementationDetails");

    /**

     * If true, report on stdout all "slow" tests, that is, ones that

     * take more than profileThreshold milliseconds to execute.

     */

    private static final boolean profileTests =

        Boolean.getBoolean("jsr166.profileTests");

    /**

     * The number of milliseconds that tests are permitted for

     * execution without being reported, when profileTests is set.

     */

    private static final long profileThreshold =

        Long.getLong("jsr166.profileThreshold", 100);

    /**

     * The number of repetitions per test (for tickling rare bugs).

     */

    private static final int runsPerTest =

        Integer.getInteger("jsr166.runsPerTest", 1);

    /**

     * The number of repetitions of the test suite (for finding leaks?).

     */

    private static final int suiteRuns =

        Integer.getInteger("jsr166.suiteRuns", 1);

    /**

     * Returns the value of the system property, or NaN if not defined.

     */

    private static float systemPropertyValue(String name) {

        String floatString = System.getProperty(name);

        if (floatString == null)

            return Float.NaN;

        try {

            return Float.parseFloat(floatString);

        } catch (NumberFormatException ex) {

            throw new IllegalArgumentException(

                String.format("Bad float value in system property %s=%s",

                              name, floatString));

        }

    }

    /**

     * The scaling factor to apply to standard delays used in tests.

     * May be initialized from any of:

     * - the "jsr166.delay.factor" system property

     * - the "test.timeout.factor" system property (as used by jtreg)

     *   See: http://openjdk.java.net/jtreg/tag-spec.html

     * - hard-coded fuzz factor when using a known slowpoke VM

     */

    private static final float delayFactor = delayFactor();

    private static float delayFactor() {

        float x;

        if (!Float.isNaN(x = systemPropertyValue("jsr166.delay.factor")))

            return x;

        if (!Float.isNaN(x = systemPropertyValue("test.timeout.factor")))

            return x;

        String prop = System.getProperty("java.vm.version");

        if (prop != null && prop.matches(".*debug.*"))

            return 4.0f; // How much slower is fastdebug than product?!

        return 1.0f;

    }

    public JSR166TestCase() { super(); }

    public JSR166TestCase(String name) { super(name); }

    /**

     * A filter for tests to run, matching strings of the form

     * methodName(className), e.g. "testInvokeAll5(ForkJoinPoolTest)"

     * Usefully combined with jsr166.runsPerTest.

     */

    private static final Pattern methodFilter = methodFilter();

    private static Pattern methodFilter() {

        String regex = System.getProperty("jsr166.methodFilter");

        return (regex == null) ? null : Pattern.compile(regex);

    }

    // Instrumentation to debug very rare, but very annoying hung test runs.

    static volatile TestCase currentTestCase;

    // static volatile int currentRun = 0;

    static {

        Runnable checkForWedgedTest = new Runnable() { public void run() {

            // Avoid spurious reports with enormous runsPerTest.

            // A single test case run should never take more than 1 second.

            // But let's cap it at the high end too ...

            final int timeoutMinutes =

                Math.min(15, Math.max(runsPerTest / 60, 1));

            for (TestCase lastTestCase = currentTestCase;;) {

                try { MINUTES.sleep(timeoutMinutes); }

                catch (InterruptedException unexpected) { break; }

                if (lastTestCase == currentTestCase) {

                    System.err.printf(

                        "Looks like we're stuck running test: %s%n",

                        lastTestCase);

//                     System.err.printf(

//                         "Looks like we're stuck running test: %s (%d/%d)%n",

//                         lastTestCase, currentRun, runsPerTest);

//                     System.err.println("availableProcessors=" +

//                         Runtime.getRuntime().availableProcessors());

//                     System.err.printf("cpu model = %s%n", cpuModel());

                    dumpTestThreads();

                    // one stack dump is probably enough; more would be spam

                    break;

                }

                lastTestCase = currentTestCase;

            }}};

        Thread thread = new Thread(checkForWedgedTest, "checkForWedgedTest");

        thread.setDaemon(true);

        thread.start();

    }

//     public static String cpuModel() {

//         try {

//             java.util.regex.Matcher matcher

//               = Pattern.compile("model name\\s*: (.*)")

//                 .matcher(new String(

//                     java.nio.file.Files.readAllBytes(

//                         java.nio.file.Paths.get("/proc/cpuinfo")), "UTF-8"));

//             matcher.find();

//             return matcher.group(1);

//         } catch (Exception ex) { return null; }

//     }

    public void runBare() throws Throwable {

        currentTestCase = this;

        if (methodFilter == null

            || methodFilter.matcher(toString()).find())

            super.runBare();

    }

    protected void runTest() throws Throwable {

        for (int i = 0; i < runsPerTest; i++) {

            // currentRun = i;

            if (profileTests)

                runTestProfiled();

            else

                super.runTest();

        }

    }

    protected void runTestProfiled() throws Throwable {

        for (int i = 0; i < 2; i++) {

            long startTime = System.nanoTime();

            super.runTest();

            long elapsedMillis = millisElapsedSince(startTime);

            if (elapsedMillis < profileThreshold)

                break;

            // Never report first run of any test; treat it as a

            // warmup run, notably to trigger all needed classloading,

            if (i > 0)

                System.out.printf("%n%s: %d%n", toString(), elapsedMillis);

        }

    }

    /**

     * Runs all JSR166 unit tests using junit.textui.TestRunner.

     */

    public static void main(String[] args) {

        main(suite(), args);

    }

    static class PithyResultPrinter extends junit.textui.ResultPrinter {

        PithyResultPrinter(java.io.PrintStream writer) { super(writer); }

        long runTime;

        public void startTest(Test test) {}

        protected void printHeader(long runTime) {

            this.runTime = runTime; // defer printing for later

        }

        protected void printFooter(TestResult result) {

            if (result.wasSuccessful()) {

                getWriter().println("OK (" + result.runCount() + " tests)"

                    + "  Time: " + elapsedTimeAsString(runTime));

            } else {

                getWriter().println("Time: " + elapsedTimeAsString(runTime));

                super.printFooter(result);

            }

        }

    }

    /**

     * Returns a TestRunner that doesn't bother with unnecessary

     * fluff, like printing a "." for each test case.

     */

    static junit.textui.TestRunner newPithyTestRunner() {

        junit.textui.TestRunner runner = new junit.textui.TestRunner();

        runner.setPrinter(new PithyResultPrinter(System.out));

        return runner;

    }

    /**

     * Runs all unit tests in the given test suite.

     * Actual behavior influenced by jsr166.* system properties.

     */

    static void main(Test suite, String[] args) {

        if (useSecurityManager) {

            System.err.println("Setting a permissive security manager");

            Policy.setPolicy(permissivePolicy());

            System.setSecurityManager(new SecurityManager());

        }

        for (int i = 0; i < suiteRuns; i++) {

            TestResult result = newPithyTestRunner().doRun(suite);

            if (!result.wasSuccessful())

                System.exit(1);

            System.gc();

            System.runFinalization();

        }

    }

    public static TestSuite newTestSuite(Object... suiteOrClasses) {

        TestSuite suite = new TestSuite();

        for (Object suiteOrClass : suiteOrClasses) {

            if (suiteOrClass instanceof TestSuite)

                suite.addTest((TestSuite) suiteOrClass);

            else if (suiteOrClass instanceof Class)

                suite.addTest(new TestSuite((Class<?>) suiteOrClass));

            else

                throw new ClassCastException("not a test suite or class");

        }

        return suite;

    }

    public static void addNamedTestClasses(TestSuite suite,

                                           String... testClassNames) {

        for (String testClassName : testClassNames) {

            try {

                Class<?> testClass = Class.forName(testClassName);

                Method m = testClass.getDeclaredMethod("suite",

                                                       new Class<?>[0]);

                suite.addTest(newTestSuite((Test)m.invoke(null)));

            } catch (Exception e) {

                throw new Error("Missing test class", e);

            }

        }

    }

    public static final double JAVA_CLASS_VERSION;

    public static final String JAVA_SPECIFICATION_VERSION;

    static {

        try {

            JAVA_CLASS_VERSION = java.security.AccessController.doPrivileged(

                new java.security.PrivilegedAction<Double>() {

                public Double run() {

                    return Double.valueOf(System.getProperty("java.class.version"));}});

            JAVA_SPECIFICATION_VERSION = java.security.AccessController.doPrivileged(

                new java.security.PrivilegedAction<String>() {

                public String run() {

                    return System.getProperty("java.specification.version");}});

        } catch (Throwable t) {

            throw new Error(t);

        }

    }

    public static boolean atLeastJava6() { return JAVA_CLASS_VERSION >= 50.0; }

    public static boolean atLeastJava7() { return JAVA_CLASS_VERSION >= 51.0; }

    public static boolean atLeastJava8() { return JAVA_CLASS_VERSION >= 52.0; }

    public static boolean atLeastJava9() {

        return JAVA_CLASS_VERSION >= 53.0

            // As of 2015-09, java9 still uses 52.0 class file version

            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?(9|[0-9][0-9])$");

    }

    public static boolean atLeastJava10() {

        return JAVA_CLASS_VERSION >= 54.0

            || JAVA_SPECIFICATION_VERSION.matches("^(1\\.)?[0-9][0-9]$");

    }

    /**

     * Collects all JSR166 unit tests as one suite.

     */

    public static Test suite() {

        // Java7+ test classes

        TestSuite suite = newTestSuite(

            ForkJoinPoolTest.suite(),

            ForkJoinTaskTest.suite(),

            RecursiveActionTest.suite(),

            RecursiveTaskTest.suite(),

            LinkedTransferQueueTest.suite(),

            PhaserTest.suite(),

            ThreadLocalRandomTest.suite(),

            AbstractExecutorServiceTest.suite(),

            AbstractQueueTest.suite(),

            AbstractQueuedSynchronizerTest.suite(),

            AbstractQueuedLongSynchronizerTest.suite(),

            ArrayBlockingQueueTest.suite(),

            ArrayDequeTest.suite(),

            ArrayListTest.suite(),

            AtomicBooleanTest.suite(),

            AtomicIntegerArrayTest.suite(),

            AtomicIntegerFieldUpdaterTest.suite(),

            AtomicIntegerTest.suite(),

            AtomicLongArrayTest.suite(),

            AtomicLongFieldUpdaterTest.suite(),

            AtomicLongTest.suite(),

            AtomicMarkableReferenceTest.suite(),

            AtomicReferenceArrayTest.suite(),

            AtomicReferenceFieldUpdaterTest.suite(),

            AtomicReferenceTest.suite(),

            AtomicStampedReferenceTest.suite(),

            ConcurrentHashMapTest.suite(),