--- jsr166/src/test/tck/JSR166TestCase.java	2015/10/23 17:34:47	1.178
+++ jsr166/src/test/tck/JSR166TestCase.java	2016/03/26 06:58:47	1.190
@@ -6,6 +6,14 @@
  * Pat Fisher, Mike Judd.
  */
 
+/*
+ * @test
+ * @summary JSR-166 tck tests
+ * @modules java.management
+ * @build *
+ * @run junit/othervm/timeout=1000 -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;
@@ -53,6 +61,7 @@ import java.util.concurrent.Semaphore;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -112,8 +121,7 @@ import junit.framework.TestSuite;
  * 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.
+ * 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
@@ -176,6 +184,44 @@ public class JSR166TestCase extends Test
     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); }
 
@@ -277,10 +323,10 @@ public class JSR166TestCase extends Test
         PithyResultPrinter(java.io.PrintStream writer) { super(writer); }
         long runTime;
         public void startTest(Test test) {}
-	protected void printHeader(long runTime) {
+        protected void printHeader(long runTime) {
             this.runTime = runTime; // defer printing for later
-	}
-	protected void printFooter(TestResult result) {
+        }
+        protected void printFooter(TestResult result) {
             if (result.wasSuccessful()) {
                 getWriter().println("OK (" + result.runCount() + " tests)"
                     + "  Time: " + elapsedTimeAsString(runTime));
@@ -465,6 +511,7 @@ public class JSR166TestCase extends Test
                 "StampedLockTest",
                 "SubmissionPublisherTest",
                 "ThreadLocalRandom8Test",
+                "TimeUnit8Test",
             };
             addNamedTestClasses(suite, java8TestClassNames);
         }
@@ -549,11 +596,13 @@ public class JSR166TestCase extends Test
     public static long LONG_DELAY_MS;
 
     /**
-     * Returns the shortest timed delay. This could
-     * be reimplemented to use for example a Property.
+     * Returns the shortest timed delay. This can be scaled up for
+     * slow machines using the jsr166.delay.factor system property,
+     * or via jtreg's -timeoutFactor: flag.
+     * http://openjdk.java.net/jtreg/command-help.html
      */
     protected long getShortDelay() {
-        return 50;
+        return (long) (50 * delayFactor);
     }
 
     /**
@@ -866,6 +915,14 @@ public class JSR166TestCase extends Test
         }};
     }
 
+    PoolCleaner cleaner(ExecutorService pool, AtomicBoolean flag) {
+        return new PoolCleanerWithReleaser(pool, releaser(flag));
+    }
+
+    Runnable releaser(final AtomicBoolean flag) {
+        return new Runnable() { public void run() { flag.set(true); }};
+    }
+
     /**
      * Waits out termination of a thread pool or fails doing so.
      */
@@ -1422,16 +1479,20 @@ public class JSR166TestCase extends Test
         return new LatchAwaiter(latch);
     }
 
-    public void await(CountDownLatch latch) {
+    public void await(CountDownLatch latch, long timeoutMillis) {
         try {
-            if (!latch.await(LONG_DELAY_MS, MILLISECONDS))
+            if (!latch.await(timeoutMillis, MILLISECONDS))
                 fail("timed out waiting for CountDownLatch for "
-                     + (LONG_DELAY_MS/1000) + " sec");
+                     + (timeoutMillis/1000) + " sec");
         } catch (Throwable fail) {
             threadUnexpectedException(fail);
         }
     }
 
+    public void await(CountDownLatch latch) {
+        await(latch, LONG_DELAY_MS);
+    }
+
     public void await(Semaphore semaphore) {
         try {
             if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))