--- jsr166/src/test/tck/ThreadPoolExecutorTest.java	2011/05/27 19:35:24	1.44
+++ jsr166/src/test/tck/ThreadPoolExecutorTest.java	2013/09/25 07:39:17	1.49
@@ -6,10 +6,10 @@
  * Pat Fisher, Mike Judd.
  */
 
+import junit.framework.*;
 import java.util.concurrent.*;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.concurrent.atomic.*;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
 import java.util.*;
 
 public class ThreadPoolExecutorTest extends JSR166TestCase {
@@ -21,20 +21,31 @@ public class ThreadPoolExecutorTest exte
     }
 
     static class ExtendedTPE extends ThreadPoolExecutor {
-        volatile boolean beforeCalled = false;
-        volatile boolean afterCalled = false;
-        volatile boolean terminatedCalled = false;
+        final CountDownLatch beforeCalled = new CountDownLatch(1);
+        final CountDownLatch afterCalled = new CountDownLatch(1);
+        final CountDownLatch terminatedCalled = new CountDownLatch(1);
+
         public ExtendedTPE() {
             super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
         }
         protected void beforeExecute(Thread t, Runnable r) {
-            beforeCalled = true;
+            beforeCalled.countDown();
         }
         protected void afterExecute(Runnable r, Throwable t) {
-            afterCalled = true;
+            afterCalled.countDown();
         }
         protected void terminated() {
-            terminatedCalled = true;
+            terminatedCalled.countDown();
+        }
+
+        public boolean beforeCalled() {
+            return beforeCalled.getCount() == 0;
+        }
+        public boolean afterCalled() {
+            return afterCalled.getCount() == 0;
+        }
+        public boolean terminatedCalled() {
+            return terminatedCalled.getCount() == 0;
         }
     }
 
@@ -149,12 +160,16 @@ public class ThreadPoolExecutorTest exte
                     threadProceed.await();
                     threadDone.countDown();
                 }});
-            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
+            await(threadStarted);
             assertEquals(0, p.getCompletedTaskCount());
             threadProceed.countDown();
             threadDone.await();
-            delay(SHORT_DELAY_MS);
-            assertEquals(1, p.getCompletedTaskCount());
+            long startTime = System.nanoTime();
+            while (p.getCompletedTaskCount() != 1) {
+                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
+                    fail("timed out");
+                Thread.yield();
+            }
         } finally {
             joinPool(p);
         }
@@ -387,6 +402,36 @@ public class ThreadPoolExecutorTest exte
     }
 
     /**
+     * awaitTermination on a non-shutdown pool times out
+     */
+    public void testAwaitTermination_timesOut() throws InterruptedException {
+        final ThreadPoolExecutor p =
+            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());
+    }
+
+    /**
      * isTerminated is false before termination, true after
      */
     public void testIsTerminated() throws InterruptedException {
@@ -1319,7 +1364,7 @@ public class ThreadPoolExecutorTest exte
     public void testTerminated() {
         ExtendedTPE p = new ExtendedTPE();
         try { p.shutdown(); } catch (SecurityException ok) { return; }
-        assertTrue(p.terminatedCalled);
+        assertTrue(p.terminatedCalled());
         joinPool(p);
     }
 
@@ -1329,12 +1374,15 @@ public class ThreadPoolExecutorTest exte
     public void testBeforeAfter() throws InterruptedException {
         ExtendedTPE p = new ExtendedTPE();
         try {
-            TrackedNoOpRunnable r = new TrackedNoOpRunnable();
-            p.execute(r);
-            delay(SHORT_DELAY_MS);
-            assertTrue(r.done);
-            assertTrue(p.beforeCalled);
-            assertTrue(p.afterCalled);
+            final CountDownLatch done = new CountDownLatch(1);
+            p.execute(new CheckedRunnable() {
+                public void realRun() {
+                    done.countDown();
+                }});
+            await(p.afterCalled);
+            assertEquals(0, done.getCount());
+            assertTrue(p.afterCalled());
+            assertTrue(p.beforeCalled());
             try { p.shutdown(); } catch (SecurityException ok) { return; }
         } finally {
             joinPool(p);
@@ -1831,16 +1879,11 @@ public class ThreadPoolExecutorTest exte
             l.add(new StringTask());
             List<Future<String>> futures =
                 e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
-            assertEquals(3, futures.size());
-            Iterator<Future<String>> it = futures.iterator();
-            Future<String> f1 = it.next();
-            Future<String> f2 = it.next();
-            Future<String> f3 = it.next();
-            assertTrue(f1.isDone());
-            assertTrue(f2.isDone());
-            assertTrue(f3.isDone());
-            assertFalse(f1.isCancelled());
-            assertTrue(f2.isCancelled());
+            assertEquals(l.size(), futures.size());
+            for (Future future : futures)
+                assertTrue(future.isDone());
+            assertFalse(futures.get(0).isCancelled());
+            assertTrue(futures.get(1).isCancelled());
         } finally {
             joinPool(e);
         }
@@ -1963,7 +2006,7 @@ public class ThreadPoolExecutorTest exte
             // enough time to run all tasks
             assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
         } finally {
-            p.shutdown();
+            joinPool(p);
         }
     }