--- jsr166/src/test/tck/JSR166TestCase.java	2015/10/09 16:24:12	1.173
+++ jsr166/src/test/tck/JSR166TestCase.java	2016/01/17 00:07:51	1.182
@@ -6,6 +6,13 @@
  * Pat Fisher, Mike Judd.
  */
 
+/*
+ * @test
+ * @summary JSR-166 tck tests
+ * @build *
+ * @run junit/othervm/timeout=1000 JSR166TestCase
+ */
+
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.MINUTES;
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
@@ -112,8 +119,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 +182,12 @@ public class JSR166TestCase extends Test
     private static final int suiteRuns =
         Integer.getInteger("jsr166.suiteRuns", 1);
 
+    /**
+     * The scaling factor to apply to standard delays used in tests.
+     */
+    private static final int delayFactor =
+        Integer.getInteger("jsr166.delay.factor", 1);
+
     public JSR166TestCase() { super(); }
     public JSR166TestCase(String name) { super(name); }
 
@@ -196,8 +208,11 @@ public class JSR166TestCase extends Test
     // static volatile int currentRun = 0;
     static {
         Runnable checkForWedgedTest = new Runnable() { public void run() {
-            // avoid spurious reports with enormous runsPerTest
-            final int timeoutMinutes = Math.max(runsPerTest / 10, 1);
+            // 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; }
@@ -208,9 +223,9 @@ public class JSR166TestCase extends Test
 //                     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());
+//                     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;
@@ -222,15 +237,15 @@ public class JSR166TestCase extends Test
         thread.start();
     }
 
-    public static String cpuModel() {
-        try {
-            Matcher matcher = Pattern.compile("model name\\s*: (.*)")
-                .matcher(new String(
-                     Files.readAllBytes(Paths.get("/proc/cpuinfo")), "UTF-8"));
-            matcher.find();
-            return matcher.group(1);
-        } catch (Exception ex) { return null; }
-    }
+//     public static String cpuModel() {
+//         try {
+//             Matcher matcher = Pattern.compile("model name\\s*: (.*)")
+//                 .matcher(new String(
+//                      Files.readAllBytes(Paths.get("/proc/cpuinfo")), "UTF-8"));
+//             matcher.find();
+//             return matcher.group(1);
+//         } catch (Exception ex) { return null; }
+//     }
 
     public void runBare() throws Throwable {
         currentTestCase = this;
@@ -270,6 +285,34 @@ public class JSR166TestCase extends Test
         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.
@@ -281,7 +324,7 @@ public class JSR166TestCase extends Test
             System.setSecurityManager(new SecurityManager());
         }
         for (int i = 0; i < suiteRuns; i++) {
-            TestResult result = junit.textui.TestRunner.run(suite);
+            TestResult result = newPithyTestRunner().doRun(suite);
             if (!result.wasSuccessful())
                 System.exit(1);
             System.gc();
@@ -518,11 +561,11 @@ 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.
      */
     protected long getShortDelay() {
-        return 50;
+        return 50 * delayFactor;
     }
 
     /**
@@ -1225,7 +1268,7 @@ public class JSR166TestCase extends Test
         } finally {
             if (t.getState() != Thread.State.TERMINATED) {
                 t.interrupt();
-                threadFail("Test timed out");
+                threadFail("timed out waiting for thread to terminate");
             }
         }
     }
@@ -1393,7 +1436,9 @@ public class JSR166TestCase extends Test
 
     public void await(CountDownLatch latch) {
         try {
-            assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
+            if (!latch.await(LONG_DELAY_MS, MILLISECONDS))
+                fail("timed out waiting for CountDownLatch for "
+                     + (LONG_DELAY_MS/1000) + " sec");
         } catch (Throwable fail) {
             threadUnexpectedException(fail);
         }
@@ -1401,7 +1446,9 @@ public class JSR166TestCase extends Test
 
     public void await(Semaphore semaphore) {
         try {
-            assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
+            if (!semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS))
+                fail("timed out waiting for Semaphore for "
+                     + (LONG_DELAY_MS/1000) + " sec");
         } catch (Throwable fail) {
             threadUnexpectedException(fail);
         }