--- jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java	2015/09/28 02:41:29	1.41
+++ jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java	2015/10/04 00:59:09	1.51
@@ -101,11 +101,13 @@ public class ThreadPoolExecutorSubclassT
             }
             lock.lock();
             try {
-                result = v;
-                exception = e;
-                done = true;
-                thread = null;
-                cond.signalAll();
+                if (!done) {
+                    result = v;
+                    exception = e;
+                    done = true;
+                    thread = null;
+                    cond.signalAll();
+                }
             }
             finally { lock.unlock(); }
         }
@@ -114,6 +116,8 @@ public class ThreadPoolExecutorSubclassT
             try {
                 while (!done)
                     cond.await();
+                if (cancelled)
+                    throw new CancellationException();
                 if (exception != null)
                     throw new ExecutionException(exception);
                 return result;
@@ -125,12 +129,13 @@ public class ThreadPoolExecutorSubclassT
             long nanos = unit.toNanos(timeout);
             lock.lock();
             try {
-                for (;;) {
-                    if (done) break;
-                    if (nanos < 0)
+                while (!done) {
+                    if (nanos <= 0L)
                         throw new TimeoutException();
                     nanos = cond.awaitNanos(nanos);
                 }
+                if (cancelled)
+                    throw new CancellationException();
                 if (exception != null)
                     throw new ExecutionException(exception);
                 return result;
@@ -227,18 +232,14 @@ public class ThreadPoolExecutorSubclassT
     public void testExecute() throws InterruptedException {
         final ThreadPoolExecutor p =
             new CustomTPE(1, 1,
-                          LONG_DELAY_MS, MILLISECONDS,
+                          2 * LONG_DELAY_MS, MILLISECONDS,
                           new ArrayBlockingQueue<Runnable>(10));
-        final CountDownLatch done = new CountDownLatch(1);
-        final Runnable task = new CheckedRunnable() {
-            public void realRun() {
-                done.countDown();
-            }};
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
+            final CountDownLatch done = new CountDownLatch(1);
+            final Runnable task = new CheckedRunnable() {
+                public void realRun() { done.countDown(); }};
             p.execute(task);
-            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
-        } finally {
-            joinPool(p);
+            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
         }
     }
 
@@ -253,7 +254,7 @@ public class ThreadPoolExecutorSubclassT
                           new ArrayBlockingQueue<Runnable>(10));
         final CountDownLatch threadStarted = new CountDownLatch(1);
         final CountDownLatch done = new CountDownLatch(1);
-        try {
+        try (PoolCleaner cleaner = cleaner(p)) {
             assertEquals(0, p.getActiveCount());
             p.execute(new CheckedRunnable() {
                 public void realRun() throws InterruptedException {
@@ -263,9 +264,7 @@ public class ThreadPoolExecutorSubclassT
                 }});
             assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
             assertEquals(1, p.getActiveCount());
-        } finally {
             done.countDown();
-            joinPool(p);
         }
     }
 
@@ -711,7 +710,7 @@ public class ThreadPoolExecutorSubclassT
             new CustomTPE(poolSize, poolSize, LONG_DELAY_MS, MILLISECONDS,
                           new ArrayBlockingQueue<Runnable>(10));
         CountDownLatch threadsStarted = new CountDownLatch(poolSize);
-        CheckedRunnable waiter = new CheckedRunnable() { public void realRun() {
+        Runnable waiter = new CheckedRunnable() { public void realRun() {
             threadsStarted.countDown();
             try {
                 MILLISECONDS.sleep(2 * LONG_DELAY_MS);
@@ -721,6 +720,8 @@ public class ThreadPoolExecutorSubclassT
         for (int i = 0; i < count; i++)
             p.execute(waiter);
         assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
+        assertEquals(poolSize, p.getActiveCount());
+        assertEquals(0, p.getCompletedTaskCount());
         final List<Runnable> queuedTasks;
         try {
             queuedTasks = p.shutdownNow();
@@ -733,6 +734,7 @@ public class ThreadPoolExecutorSubclassT
         assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
         assertTrue(p.isTerminated());
         assertEquals(poolSize, ran.get());
+        assertEquals(poolSize, p.getCompletedTaskCount());
     }
 
     // Exception Tests
@@ -1741,7 +1743,7 @@ public class ThreadPoolExecutorSubclassT
             l.add(new StringTask());
             l.add(new StringTask());
             List<Future<String>> futures =
-                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
+                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
             assertEquals(2, futures.size());
             for (Future<String> future : futures)
                 assertSame(TEST_STRING, future.get());
@@ -1871,4 +1873,45 @@ public class ThreadPoolExecutorSubclassT
         }
     }
 
+    /**
+     * get(cancelled task) throws CancellationException
+     * (in part, a test of CustomTPE itself)
+     */
+    public void testGet_cancelled() throws Exception {
+        final ExecutorService e =
+            new CustomTPE(1, 1,
+                          LONG_DELAY_MS, MILLISECONDS,
+                          new LinkedBlockingQueue<Runnable>());
+        try {
+            final CountDownLatch blockerStarted = new CountDownLatch(1);
+            final CountDownLatch done = new CountDownLatch(1);
+            final List<Future<?>> futures = new ArrayList<>();
+            for (int i = 0; i < 2; i++) {
+                Runnable r = new CheckedRunnable() { public void realRun()
+                                                         throws Throwable {
+                    blockerStarted.countDown();
+                    assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
+                }};
+                futures.add(e.submit(r));
+            }
+            assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
+            for (Future<?> future : futures) future.cancel(false);
+            for (Future<?> future : futures) {
+                try {
+                    future.get();
+                    shouldThrow();
+                } catch (CancellationException success) {}
+                try {
+                    future.get(LONG_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (CancellationException success) {}
+                assertTrue(future.isCancelled());
+                assertTrue(future.isDone());
+            }
+            done.countDown();
+        } finally {
+            joinPool(e);
+        }
+    }
+
 }