--- jsr166/src/test/tck/ThreadPoolExecutorTest.java	2015/10/04 02:24:49	1.81
+++ jsr166/src/test/tck/ThreadPoolExecutorTest.java	2015/10/04 02:49:18	1.89
@@ -426,10 +426,11 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    new ArrayBlockingQueue<Runnable>(10));
-        assertFalse(p.isShutdown());
-        try { p.shutdown(); } catch (SecurityException ok) { return; }
-        assertTrue(p.isShutdown());
-        joinPool(p);
+        try (PoolCleaner cleaner = cleaner(p)) {
+            assertFalse(p.isShutdown());
+            try { p.shutdown(); } catch (SecurityException ok) { return; }
+            assertTrue(p.isShutdown());
+        }
     }
 
     /**
@@ -440,26 +441,28 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    new ArrayBlockingQueue<Runnable>(10));
-        assertFalse(p.isTerminated());
-        assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
-        assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
-        assertFalse(p.awaitTermination(-1L, NANOSECONDS));
-        assertFalse(p.awaitTermination(-1L, MILLISECONDS));
-        assertFalse(p.awaitTermination(0L, NANOSECONDS));
-        assertFalse(p.awaitTermination(0L, MILLISECONDS));
-        long timeoutNanos = 999999L;
-        long startTime = System.nanoTime();
-        assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
-        assertTrue(System.nanoTime() - startTime >= timeoutNanos);
-        assertFalse(p.isTerminated());
-        startTime = System.nanoTime();
-        long timeoutMillis = timeoutMillis();
-        assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
-        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
-        assertFalse(p.isTerminated());
-        p.shutdown();
-        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
-        assertTrue(p.isTerminated());
+        try (PoolCleaner cleaner = cleaner(p)) {
+            assertFalse(p.isTerminated());
+            assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
+            assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
+            assertFalse(p.awaitTermination(-1L, NANOSECONDS));
+            assertFalse(p.awaitTermination(-1L, MILLISECONDS));
+            assertFalse(p.awaitTermination(0L, NANOSECONDS));
+            assertFalse(p.awaitTermination(0L, MILLISECONDS));
+            long timeoutNanos = 999999L;
+            long startTime = System.nanoTime();
+            assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
+            assertTrue(System.nanoTime() - startTime >= timeoutNanos);
+            assertFalse(p.isTerminated());
+            startTime = System.nanoTime();
+            long timeoutMillis = timeoutMillis();
+            assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
+            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
+            assertFalse(p.isTerminated());
+            try { p.shutdown(); } catch (SecurityException ok) { return; }
+            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
+            assertTrue(p.isTerminated());
+        }
     }
 
     /**
@@ -470,24 +473,24 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    new ArrayBlockingQueue<Runnable>(10));
-        final CountDownLatch threadStarted = new CountDownLatch(1);
-        final CountDownLatch done = new CountDownLatch(1);
-        assertFalse(p.isTerminated());
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            final CountDownLatch threadStarted = new CountDownLatch(1);
+            final CountDownLatch done = new CountDownLatch(1);
+            assertFalse(p.isTerminating());
             p.execute(new CheckedRunnable() {
                 public void realRun() throws InterruptedException {
-                    assertFalse(p.isTerminated());
+                    assertFalse(p.isTerminating());
                     threadStarted.countDown();
                     done.await();
                 }});
             assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
             assertFalse(p.isTerminating());
             done.countDown();
-        } finally {
             try { p.shutdown(); } catch (SecurityException ok) { return; }
+            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
+            assertTrue(p.isTerminated());
+            assertFalse(p.isTerminating());
         }
-        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
-        assertTrue(p.isTerminated());
     }
 
     /**
@@ -498,9 +501,9 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    new ArrayBlockingQueue<Runnable>(10));
-        final CountDownLatch threadStarted = new CountDownLatch(1);
-        final CountDownLatch done = new CountDownLatch(1);
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            final CountDownLatch threadStarted = new CountDownLatch(1);
+            final CountDownLatch done = new CountDownLatch(1);
             assertFalse(p.isTerminating());
             p.execute(new CheckedRunnable() {
                 public void realRun() throws InterruptedException {
@@ -511,12 +514,11 @@ public class ThreadPoolExecutorTest exte
             assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
             assertFalse(p.isTerminating());
             done.countDown();
-        } finally {
             try { p.shutdown(); } catch (SecurityException ok) { return; }
+            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
+            assertTrue(p.isTerminated());
+            assertFalse(p.isTerminating());
         }
-        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
-        assertTrue(p.isTerminated());
-        assertFalse(p.isTerminating());
     }
 
     /**
@@ -528,9 +530,9 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    q);
-        final CountDownLatch threadStarted = new CountDownLatch(1);
-        final CountDownLatch done = new CountDownLatch(1);
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            final CountDownLatch threadStarted = new CountDownLatch(1);
+            final CountDownLatch done = new CountDownLatch(1);
             FutureTask[] tasks = new FutureTask[5];
             for (int i = 0; i < tasks.length; i++) {
                 Callable task = new CheckedCallable<Boolean>() {
@@ -548,9 +550,7 @@ public class ThreadPoolExecutorTest exte
             assertFalse(q.contains(tasks[0]));
             assertTrue(q.contains(tasks[tasks.length - 1]));
             assertEquals(tasks.length - 1, q.size());
-        } finally {
             done.countDown();
-            joinPool(p);
         }
     }
 
@@ -563,10 +563,10 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    q);
-        Runnable[] tasks = new Runnable[5];
-        final CountDownLatch threadStarted = new CountDownLatch(1);
-        final CountDownLatch done = new CountDownLatch(1);
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            Runnable[] tasks = new Runnable[6];
+            final CountDownLatch threadStarted = new CountDownLatch(1);
+            final CountDownLatch done = new CountDownLatch(1);
             for (int i = 0; i < tasks.length; i++) {
                 tasks[i] = new CheckedRunnable() {
                     public void realRun() throws InterruptedException {
@@ -585,9 +585,7 @@ public class ThreadPoolExecutorTest exte
             assertTrue(q.contains(tasks[3]));
             assertTrue(p.remove(tasks[3]));
             assertFalse(q.contains(tasks[3]));
-        } finally {
             done.countDown();
-            joinPool(p);
         }
     }
 
@@ -602,8 +600,8 @@ public class ThreadPoolExecutorTest exte
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    q);
-        FutureTask[] tasks = new FutureTask[5];
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            FutureTask[] tasks = new FutureTask[5];
             for (int i = 0; i < tasks.length; i++) {
                 Callable task = new CheckedCallable<Boolean>() {
                     public Boolean realCall() throws InterruptedException {
@@ -627,9 +625,7 @@ public class ThreadPoolExecutorTest exte
             p.purge();         // Nothing to do
             assertEquals(tasks.length - 3, q.size());
             assertEquals(tasks.length - 2, p.getTaskCount());
-        } finally {
             done.countDown();
-            joinPool(p);
         }
     }
 
@@ -1022,9 +1018,9 @@ public class ThreadPoolExecutorTest exte
                                    60, SECONDS,
                                    new ArrayBlockingQueue<Runnable>(10));
 
-        final CountDownLatch threadStarted = new CountDownLatch(1);
-        final CountDownLatch done = new CountDownLatch(1);
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            final CountDownLatch threadStarted = new CountDownLatch(1);
+            final CountDownLatch done = new CountDownLatch(1);
             Thread t = newStartedThread(new CheckedInterruptedRunnable() {
                 public void realRun() throws Exception {
                     Callable task = new CheckedCallable<Boolean>() {
@@ -1039,9 +1035,7 @@ public class ThreadPoolExecutorTest exte
             assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
             t.interrupt();
             awaitTermination(t, MEDIUM_DELAY_MS);
-        } finally {
             done.countDown();
-            joinPool(p);
         }
     }
 
@@ -1049,12 +1043,12 @@ public class ThreadPoolExecutorTest exte
      * execute throws RejectedExecutionException if saturated.
      */
     public void testSaturatedExecute() {
-        ThreadPoolExecutor p =
+        final ThreadPoolExecutor p =
             new ThreadPoolExecutor(1, 1,
                                    LONG_DELAY_MS, MILLISECONDS,
                                    new ArrayBlockingQueue<Runnable>(1));
-        final CountDownLatch done = new CountDownLatch(1);
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            final CountDownLatch done = new CountDownLatch(1);
             Runnable task = new CheckedRunnable() {
                 public void realRun() throws InterruptedException {
                     done.await();
@@ -1068,9 +1062,7 @@ public class ThreadPoolExecutorTest exte
                 } catch (RejectedExecutionException success) {}
                 assertTrue(p.getTaskCount() <= 2);
             }
-        } finally {
             done.countDown();
-            joinPool(p);
         }
     }