--- jsr166/src/test/tck/JSR166TestCase.java	2015/10/03 16:57:25	1.149
+++ jsr166/src/test/tck/JSR166TestCase.java	2015/10/05 22:34:45	1.167
@@ -7,6 +7,7 @@
  */
 
 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;
@@ -15,6 +16,7 @@ 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;
@@ -186,7 +188,31 @@ public class JSR166TestCase extends Test
         return (regex == null) ? null : Pattern.compile(regex);
     }
 
+    static volatile TestCase currentTestCase;
+    static {
+        Runnable checkForWedgedTest = new Runnable() { public void run() {
+            // avoid spurious reports with enormous runsPerTest
+            final int timeoutMinutes = Math.max(runsPerTest / 10, 1);
+            for (TestCase lastTestCase = currentTestCase;;) {
+                try { MINUTES.sleep(timeoutMinutes); }
+                catch (InterruptedException unexpected) { break; }
+                if (lastTestCase == currentTestCase) {
+                    System.err.println
+                        ("Looks like we're stuck running test: "
+                         + lastTestCase);
+                    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 void runBare() throws Throwable {
+        currentTestCase = this;
         if (methodFilter == null
             || methodFilter.matcher(toString()).find())
             super.runBare();
@@ -460,7 +486,6 @@ public class JSR166TestCase extends Test
         } else {
             return new TestSuite();
         }
-
     }
 
     // Delays for timing-dependent tests, in milliseconds.
@@ -518,6 +543,8 @@ public class JSR166TestCase extends Test
      * the same test have no effect.
      */
     public void threadRecordFailure(Throwable t) {
+        System.err.println(t);
+        dumpTestThreads();
         threadFailure.compareAndSet(null, t);
     }
 
@@ -528,7 +555,7 @@ public class JSR166TestCase extends Test
     void tearDownFail(String format, Object... args) {
         String msg = toString() + ": " + String.format(format, args);
         System.err.println(msg);
-        printAllStackTraces();
+        dumpTestThreads();
         throw new AssertionFailedError(msg);
     }
 
@@ -565,7 +592,7 @@ public class JSR166TestCase extends Test
     }
 
     /**
-     * Finds missing try { ... } finally { joinPool(e); }
+     * Finds missing PoolCleaners
      */
     void checkForkJoinPoolThreadLeaks() throws InterruptedException {
         Thread[] survivors = new Thread[7];
@@ -597,7 +624,7 @@ public class JSR166TestCase extends Test
             fail(reason);
         } catch (AssertionFailedError t) {
             threadRecordFailure(t);
-            fail(reason);
+            throw t;
         }
     }
 
@@ -724,47 +751,88 @@ public class JSR166TestCase extends Test
     /**
      * Delays, via Thread.sleep, for the given millisecond delay, but
      * if the sleep is shorter than specified, may re-sleep or yield
-     * until time elapses.
+     * until time elapses.  Ensures that the given time, as measured
+     * by System.nanoTime(), has elapsed.
      */
     static void delay(long millis) throws InterruptedException {
-        long startTime = System.nanoTime();
-        long ns = millis * 1000 * 1000;
-        for (;;) {
+        long nanos = millis * (1000 * 1000);
+        final long wakeupTime = System.nanoTime() + nanos;
+        do {
             if (millis > 0L)
                 Thread.sleep(millis);
             else // too short to sleep
                 Thread.yield();
-            long d = ns - (System.nanoTime() - startTime);
-            if (d > 0L)
-                millis = d / (1000 * 1000);
-            else
-                break;
-        }
+            nanos = wakeupTime - System.nanoTime();
+            millis = nanos / (1000 * 1000);
+        } while (nanos >= 0L);
     }
 
     /**
      * Allows use of try-with-resources with per-test thread pools.
      */
-    static class PoolCloser<T extends ExecutorService>
-            implements AutoCloseable {
-        public final T pool;
-        public PoolCloser(T pool) { this.pool = pool; }
+    class PoolCleaner implements AutoCloseable {
+        private final ExecutorService pool;
+        public PoolCleaner(ExecutorService pool) { this.pool = pool; }
         public void close() { joinPool(pool); }
     }
 
     /**
+     * An extension of PoolCleaner that has an action to release the pool.
+     */
+    class PoolCleanerWithReleaser extends PoolCleaner {
+        private final Runnable releaser;
+        public PoolCleanerWithReleaser(ExecutorService pool, Runnable releaser) {
+            super(pool);
+            this.releaser = releaser;
+        }
+        public void close() {
+            try {
+                releaser.run();
+            } finally {
+                super.close();
+            }
+        }
+    }
+
+    PoolCleaner cleaner(ExecutorService pool) {
+        return new PoolCleaner(pool);
+    }
+
+    PoolCleaner cleaner(ExecutorService pool, Runnable releaser) {
+        return new PoolCleanerWithReleaser(pool, releaser);
+    }
+
+    PoolCleaner cleaner(ExecutorService pool, CountDownLatch latch) {
+        return new PoolCleanerWithReleaser(pool, releaser(latch));
+    }
+
+    Runnable releaser(final CountDownLatch latch) {
+        return new Runnable() { public void run() {
+            do { latch.countDown(); }
+            while (latch.getCount() > 0);
+        }};
+    }
+
+    /**
      * Waits out termination of a thread pool or fails doing so.
      */
-    static void joinPool(ExecutorService pool) {
+    void joinPool(ExecutorService pool) {
         try {
             pool.shutdown();
-            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
-                fail("ExecutorService " + pool +
-                     " did not terminate in a timely manner");
+            if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS)) {
+                try {
+                    threadFail("ExecutorService " + pool +
+                               " did not terminate in a timely manner");
+                } finally {
+                    // last resort, for the benefit of subsequent tests
+                    pool.shutdownNow();
+                    pool.awaitTermination(MEDIUM_DELAY_MS, MILLISECONDS);
+                }
+            }
         } catch (SecurityException ok) {
             // Allowed in case test doesn't have privs
         } catch (InterruptedException fail) {
-            fail("Unexpected InterruptedException");
+            threadFail("Unexpected InterruptedException");
         }
     }
 
@@ -778,7 +846,7 @@ public class JSR166TestCase extends Test
      */
     void testInParallel(Action ... actions) {
         ExecutorService pool = Executors.newCachedThreadPool();
-        try {
+        try (PoolCleaner cleaner = cleaner(pool)) {
             ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
             for (final Action action : actions)
                 futures.add(pool.submit(new CheckedRunnable() {
@@ -791,19 +859,31 @@ public class JSR166TestCase extends Test
                 } catch (Exception ex) {
                     threadUnexpectedException(ex);
                 }
-        } finally {
-            joinPool(pool);
         }
     }
 
     /**
-     * A debugging tool to print all stack traces, as jstack does.
+     * A debugging tool to print stack traces of most threads, as jstack does.
+     * Uninteresting threads are filtered out.
      */
-    static void printAllStackTraces() {
-        for (ThreadInfo info :
-                 ManagementFactory.getThreadMXBean()
-                 .dumpAllThreads(true, true))
+    static void dumpTestThreads() {
+        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
+        System.err.println("------ stacktrace dump start ------");
+        for (ThreadInfo info : threadMXBean.dumpAllThreads(true, true)) {
+            String name = info.getThreadName();
+            if ("Signal Dispatcher".equals(name))
+                continue;
+            if ("Reference Handler".equals(name)
+                && info.getLockName().startsWith("java.lang.ref.Reference$Lock"))
+                continue;
+            if ("Finalizer".equals(name)
+                && info.getLockName().startsWith("java.lang.ref.ReferenceQueue$Lock"))
+                continue;
+            if ("checkForWedgedTest".equals(name))
+                continue;
             System.err.print(info);
+        }
+        System.err.println("------ stacktrace dump end ------");
     }
 
     /**
@@ -823,7 +903,7 @@ public class JSR166TestCase extends Test
             delay(millis);
             assertTrue(thread.isAlive());
         } catch (InterruptedException fail) {
-            fail("Unexpected InterruptedException");
+            threadFail("Unexpected InterruptedException");
         }
     }
 
@@ -845,7 +925,7 @@ public class JSR166TestCase extends Test
             for (Thread thread : threads)
                 assertTrue(thread.isAlive());
         } catch (InterruptedException fail) {
-            fail("Unexpected InterruptedException");
+            threadFail("Unexpected InterruptedException");
         }
     }
 
@@ -1271,11 +1351,22 @@ public class JSR166TestCase extends Test
             }};
     }
 
-    public Runnable awaiter(final CountDownLatch latch) {
-        return new CheckedRunnable() {
-            public void realRun() throws InterruptedException {
-                await(latch);
-            }};
+    class LatchAwaiter extends CheckedRunnable {
+        static final int NEW = 0;
+        static final int RUNNING = 1;
+        static final int DONE = 2;
+        final CountDownLatch latch;
+        int state = NEW;
+        LatchAwaiter(CountDownLatch latch) { this.latch = latch; }
+        public void realRun() throws InterruptedException {
+            state = 1;
+            await(latch);
+            state = 2;
+        }
+    }
+
+    public LatchAwaiter awaiter(CountDownLatch latch) {
+        return new LatchAwaiter(latch);
     }
 
     public void await(CountDownLatch latch) {