--- jsr166/src/test/tck/JSR166TestCase.java	2015/09/25 05:41:29	1.145
+++ jsr166/src/test/tck/JSR166TestCase.java	2015/10/03 19:19:01	1.151
@@ -15,6 +15,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;
@@ -40,6 +41,7 @@ import java.util.concurrent.CyclicBarrie
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.Future;
 import java.util.concurrent.RecursiveAction;
 import java.util.concurrent.RecursiveTask;
@@ -185,15 +187,18 @@ public class JSR166TestCase extends Test
         return (regex == null) ? null : Pattern.compile(regex);
     }
 
-    protected void runTest() throws Throwable {
+    public void runBare() throws Throwable {
         if (methodFilter == null
-            || methodFilter.matcher(toString()).find()) {
-            for (int i = 0; i < runsPerTest; i++) {
-                if (profileTests)
-                    runTestProfiled();
-                else
-                    super.runTest();
-            }
+            || methodFilter.matcher(toString()).find())
+            super.runBare();
+    }
+
+    protected void runTest() throws Throwable {
+        for (int i = 0; i < runsPerTest; i++) {
+            if (profileTests)
+                runTestProfiled();
+            else
+                super.runTest();
         }
     }
 
@@ -521,6 +526,13 @@ public class JSR166TestCase extends Test
         setDelays();
     }
 
+    void tearDownFail(String format, Object... args) {
+        String msg = toString() + ": " + String.format(format, args);
+        System.err.println(msg);
+        printAllStackTraces();
+        throw new AssertionFailedError(msg);
+    }
+
     /**
      * Extra checks that get done for all test cases.
      *
@@ -548,7 +560,7 @@ public class JSR166TestCase extends Test
         }
 
         if (Thread.interrupted())
-            throw new AssertionFailedError("interrupt status set in main thread");
+            tearDownFail("interrupt status set in main thread");
 
         checkForkJoinPoolThreadLeaks();
     }
@@ -557,7 +569,7 @@ public class JSR166TestCase extends Test
      * Finds missing try { ... } finally { joinPool(e); }
      */
     void checkForkJoinPoolThreadLeaks() throws InterruptedException {
-        Thread[] survivors = new Thread[5];
+        Thread[] survivors = new Thread[7];
         int count = Thread.enumerate(survivors);
         for (int i = 0; i < count; i++) {
             Thread thread = survivors[i];
@@ -565,12 +577,15 @@ public class JSR166TestCase extends Test
             if (name.startsWith("ForkJoinPool-")) {
                 // give thread some time to terminate
                 thread.join(LONG_DELAY_MS);
-                if (!thread.isAlive()) continue;
-                throw new AssertionFailedError
-                    (String.format("Found leaked ForkJoinPool thread test=%s thread=%s%n",
-                                   toString(), name));
+                if (thread.isAlive())
+                    tearDownFail("Found leaked ForkJoinPool thread thread=%s",
+                                 thread);
             }
         }
+
+        if (!ForkJoinPool.commonPool()
+            .awaitQuiescence(LONG_DELAY_MS, MILLISECONDS))
+            tearDownFail("ForkJoin common pool thread stuck");
     }
 
     /**
@@ -729,9 +744,19 @@ public class JSR166TestCase extends Test
     }
 
     /**
+     * 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; }
+        public void close() { joinPool(pool); }
+    }
+
+    /**
      * Waits out termination of a thread pool or fails doing so.
      */
-    void joinPool(ExecutorService pool) {
+    static void joinPool(ExecutorService pool) {
         try {
             pool.shutdown();
             if (!pool.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
@@ -753,8 +778,9 @@ public class JSR166TestCase extends Test
      * necessarily individually slow because they must block.
      */
     void testInParallel(Action ... actions) {
-        ExecutorService pool = Executors.newCachedThreadPool();
-        try {
+        try (PoolCloser<ExecutorService> poolCloser
+             = new PoolCloser<>(Executors.newCachedThreadPool())) {
+            ExecutorService pool = poolCloser.pool;
             ArrayList<Future<?>> futures = new ArrayList<>(actions.length);
             for (final Action action : actions)
                 futures.add(pool.submit(new CheckedRunnable() {
@@ -767,19 +793,29 @@ public class JSR166TestCase extends Test
                 } catch (Exception ex) {
                     threadUnexpectedException(ex);
                 }
-        } finally {
-            joinPool(pool);
         }
     }
 
     /**
      * A debugging tool to print all stack traces, as jstack does.
+     * Uninteresting threads are filtered out.
      */
     static void printAllStackTraces() {
-        for (ThreadInfo info :
-                 ManagementFactory.getThreadMXBean()
-                 .dumpAllThreads(true, true))
+        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;
             System.err.print(info);
+        }
+        System.err.println("------ stacktrace dump end ------");
     }
 
     /**
@@ -1240,6 +1276,13 @@ public class JSR166TestCase extends Test
             }};
     }
 
+    public Runnable countDowner(final CountDownLatch latch) {
+        return new CheckedRunnable() {
+            public void realRun() throws InterruptedException {
+                latch.countDown();
+            }};
+    }
+
     public Runnable awaiter(final CountDownLatch latch) {
         return new CheckedRunnable() {
             public void realRun() throws InterruptedException {