--- jsr166/src/test/tck/JSR166TestCase.java	2016/02/22 19:43:27	1.186
+++ jsr166/src/test/tck/JSR166TestCase.java	2016/05/23 18:42:17	1.194
@@ -12,6 +12,7 @@
  * @modules java.management
  * @build *
  * @run junit/othervm/timeout=1000 -Djsr166.testImplementationDetails=true JSR166TestCase
+ * @run junit/othervm/timeout=1000 -Djava.util.concurrent.ForkJoinPool.common.parallelism=0 -Djsr166.testImplementationDetails=true JSR166TestCase
  */
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
@@ -58,6 +59,7 @@ import java.util.concurrent.RecursiveAct
 import java.util.concurrent.RecursiveTask;
 import java.util.concurrent.RejectedExecutionHandler;
 import java.util.concurrent.Semaphore;
+import java.util.concurrent.SynchronousQueue;
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeoutException;
@@ -184,10 +186,13 @@ public class JSR166TestCase extends Test
     private static final int suiteRuns =
         Integer.getInteger("jsr166.suiteRuns", 1);
 
-    private static float systemPropertyValue(String name, float defaultValue) {
+    /**
+     * 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 defaultValue;
+            return Float.NaN;
         try {
             return Float.parseFloat(floatString);
         } catch (NumberFormatException ex) {
@@ -199,16 +204,25 @@ public class JSR166TestCase extends Test
 
     /**
      * The scaling factor to apply to standard delays used in tests.
-     */
-    private static final float delayFactor =
-        systemPropertyValue("jsr166.delay.factor", 1.0f);
-
-    /**
-     * The timeout factor as used in the jtreg test harness.
-     * See: http://openjdk.java.net/jtreg/tag-spec.html
-     */
-    private static final float jtregTestTimeoutFactor
-        = systemPropertyValue("test.timeout.factor", 1.0f);
+     * 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); }
@@ -499,6 +513,7 @@ public class JSR166TestCase extends Test
                 "StampedLockTest",
                 "SubmissionPublisherTest",
                 "ThreadLocalRandom8Test",
+                "TimeUnit8Test",
             };
             addNamedTestClasses(suite, java8TestClassNames);
         }
@@ -506,7 +521,7 @@ public class JSR166TestCase extends Test
         // Java9+ test classes
         if (atLeastJava9()) {
             String[] java9TestClassNames = {
-                // Currently empty, but expecting varhandle tests
+                "ExecutorCompletionService9Test",
             };
             addNamedTestClasses(suite, java9TestClassNames);
         }
@@ -585,11 +600,11 @@ public class JSR166TestCase extends Test
     /**
      * 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:<val> flag.
+     * or via jtreg's -timeoutFactor: flag.
      * http://openjdk.java.net/jtreg/command-help.html
      */
     protected long getShortDelay() {
-        return (long) (50 * delayFactor * jtregTestTimeoutFactor);
+        return (long) (50 * delayFactor);
     }
 
     /**
@@ -1466,16 +1481,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))
@@ -1816,4 +1835,19 @@ public class JSR166TestCase extends Test
         } catch (NoSuchElementException success) {}
         assertFalse(it.hasNext());
     }
+
+    public <T> Callable<T> callableThrowing(final Exception ex) {
+        return new Callable<T>() { public T call() throws Exception { throw ex; }};
+    }
+
+    public Runnable runnableThrowing(final RuntimeException ex) {
+        return new Runnable() { public void run() { throw ex; }};
+    }
+
+    /** A reusable thread pool to be shared by tests. */
+    static final ExecutorService cachedThreadPool =
+        new ThreadPoolExecutor(0, Integer.MAX_VALUE,
+                               1000L, MILLISECONDS,
+                               new SynchronousQueue<Runnable>());
+
 }