--- jsr166/src/test/tck/ExecutorCompletionServiceTest.java	2005/07/08 20:00:10	1.4
+++ jsr166/src/test/tck/ExecutorCompletionServiceTest.java	2016/05/03 23:06:12	1.23
@@ -1,232 +1,215 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
- * Other contributors include Andrew Wright, Jeffrey Hayes, 
- * Pat Fisher, Mike Judd. 
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ * Other contributors include Andrew Wright, Jeffrey Hayes,
+ * Pat Fisher, Mike Judd.
  */
 
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
-import java.math.BigInteger;
-import java.security.*;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletionService;
+import java.util.concurrent.ExecutorCompletionService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
-public class ExecutorCompletionServiceTest extends JSR166TestCase{
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class ExecutorCompletionServiceTest extends JSR166TestCase {
     public static void main(String[] args) {
-        junit.textui.TestRunner.run (suite());  
+        main(suite(), args);
     }
     public static Test suite() {
         return new TestSuite(ExecutorCompletionServiceTest.class);
     }
 
-
     /**
      * Creating a new ECS with null Executor throw NPE
-     */ 
+     */
     public void testConstructorNPE() {
         try {
-            ExecutorCompletionService ecs = new ExecutorCompletionService(null);
+            new ExecutorCompletionService(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Creating a new ECS with null queue throw NPE
-     */ 
+     */
     public void testConstructorNPE2() {
         try {
             ExecutorService e = Executors.newCachedThreadPool();
-            ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
+            new ExecutorCompletionService(e, null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
      * Submitting a null callable throws NPE
-     */ 
+     */
     public void testSubmitNPE() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
+        final ExecutorService e = Executors.newCachedThreadPool();
+        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
             Callable c = null;
-            ecs.submit(c);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
+            try {
+                ecs.submit(c);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * Submitting a null runnable throws NPE
-     */ 
+     */
     public void testSubmitNPE2() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
+        final ExecutorService e = Executors.newCachedThreadPool();
+        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
             Runnable r = null;
-            ecs.submit(r, Boolean.TRUE);
-            shouldThrow();
-        } catch (NullPointerException success) {
-        } finally {
-            joinPool(e);
+            try {
+                ecs.submit(r, Boolean.TRUE);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * A taken submitted task is completed
-     */ 
-    public void testTake() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
+     */
+    public void testTake() throws InterruptedException {
+        final ExecutorService e = Executors.newCachedThreadPool();
+        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
             Callable c = new StringTask();
             ecs.submit(c);
             Future f = ecs.take();
             assertTrue(f.isDone());
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
         }
     }
 
     /**
      * Take returns the same future object returned by submit
-     */ 
-    public void testTake2() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
+     */
+    public void testTake2() throws InterruptedException {
+        final ExecutorService e = Executors.newCachedThreadPool();
+        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
             Callable c = new StringTask();
             Future f1 = ecs.submit(c);
             Future f2 = ecs.take();
             assertSame(f1, f2);
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
         }
     }
 
     /**
      * If poll returns non-null, the returned task is completed
-     */ 
-    public void testPoll1() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
+     */
+    public void testPoll1() throws Exception {
+        final ExecutorService e = Executors.newCachedThreadPool();
+        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
             assertNull(ecs.poll());
             Callable c = new StringTask();
             ecs.submit(c);
-            Thread.sleep(SHORT_DELAY_MS);
-            for (;;) {
-                Future f = ecs.poll();
-                if (f != null) {
-                    assertTrue(f.isDone());
-                    break;
-                }
+
+            long startTime = System.nanoTime();
+            Future f;
+            while ((f = ecs.poll()) == null) {
+                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
+                    fail("timed out");
+                Thread.yield();
             }
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            assertTrue(f.isDone());
+            assertSame(TEST_STRING, f.get());
         }
     }
 
     /**
      * If timed poll returns non-null, the returned task is completed
-     */ 
-    public void testPoll2() {
-        ExecutorService e = Executors.newCachedThreadPool();
-        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
-        try {
+     */
+    public void testPoll2() throws InterruptedException {
+        final ExecutorService e = Executors.newCachedThreadPool();
+        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
             assertNull(ecs.poll());
             Callable c = new StringTask();
             ecs.submit(c);
-            Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-            if (f != null) 
+            Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
+            if (f != null)
                 assertTrue(f.isDone());
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
-        }
-    }
-     /**
-      * Submitting to underlying AES that overrides newTaskFor(Callable)
-      * returns and eventually runs Future returned by newTaskFor.
-      */
-     public void testNewTaskForCallable() {
-         final AtomicBoolean done = new AtomicBoolean(false);
-         class MyCallableFuture<V> extends FutureTask<V> {
-             MyCallableFuture(Callable<V> c) { super(c); }
-             protected void done() { done.set(true); }
-         }
-         ExecutorService e = new ThreadPoolExecutor(
-                                 1, 1, 30L, TimeUnit.SECONDS,
-                                 new ArrayBlockingQueue<Runnable>(1)) {
-             protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
-                 return new MyCallableFuture<T>(c);
-             }
-         };
-         ExecutorCompletionService<String> ecs =
-             new ExecutorCompletionService<String>(e);
-         try {
-             assertNull(ecs.poll());
-             Callable<String> c = new StringTask();
-             Future f1 = ecs.submit(c);
-             assertTrue("submit must return MyCallableFuture",
-                        f1 instanceof MyCallableFuture);
-             Future f2 = ecs.take();
-             assertSame("submit and take must return same objects", f1, f2);
-             assertTrue("completed task must have set done", done.get());
-         } catch (Exception ex) {
-             unexpectedException();
-         } finally {
-             joinPool(e);
-         }
-     }
-
-     /**
-      * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
-      * returns and eventually runs Future returned by newTaskFor.
-      */
-     public void testNewTaskForRunnable() {
-         final AtomicBoolean done = new AtomicBoolean(false);
-         class MyRunnableFuture<V> extends FutureTask<V> {
-             MyRunnableFuture(Runnable t, V r) { super(t, r); }
-             protected void done() { done.set(true); }
-         }
-         ExecutorService e = new ThreadPoolExecutor(
-                                 1, 1, 30L, TimeUnit.SECONDS,
-                                 new ArrayBlockingQueue<Runnable>(1)) {
-             protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
-                 return new MyRunnableFuture<T>(t, r);
-             }
-         };
-         ExecutorCompletionService<String> ecs =
-             new ExecutorCompletionService<String>(e);
-         try {
-             assertNull(ecs.poll());
-             Callable<String> c = new StringTask();
-             Future f1 = ecs.submit(c);
-             assertTrue("submit must return MyRunnableFuture",
-                        f1 instanceof MyRunnableFuture);
-             Future f2 = ecs.take();
-             assertSame("submit and take must return same objects", f1, f2);
-             assertTrue("completed task must have set done", done.get());
-         } catch (Exception ex) {
-             unexpectedException();
-         } finally {
-             joinPool(e);
-         }
-     }
+        }
+    }
 
+    /**
+     * Submitting to underlying AES that overrides newTaskFor(Callable)
+     * returns and eventually runs Future returned by newTaskFor.
+     */
+    public void testNewTaskForCallable() throws InterruptedException {
+        final AtomicBoolean done = new AtomicBoolean(false);
+        class MyCallableFuture<V> extends FutureTask<V> {
+            MyCallableFuture(Callable<V> c) { super(c); }
+            protected void done() { done.set(true); }
+        }
+        final ExecutorService e =
+            new ThreadPoolExecutor(1, 1,
+                                   30L, TimeUnit.SECONDS,
+                                   new ArrayBlockingQueue<Runnable>(1)) {
+                protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
+                    return new MyCallableFuture<T>(c);
+                }};
+        CompletionService<String> ecs =
+            new ExecutorCompletionService<>(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
+            assertNull(ecs.poll());
+            Callable<String> c = new StringTask();
+            Future f1 = ecs.submit(c);
+            assertTrue("submit must return MyCallableFuture",
+                       f1 instanceof MyCallableFuture);
+            Future f2 = ecs.take();
+            assertSame("submit and take must return same objects", f1, f2);
+            assertTrue("completed task must have set done", done.get());
+        }
+    }
 
+    /**
+     * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
+     * returns and eventually runs Future returned by newTaskFor.
+     */
+    public void testNewTaskForRunnable() throws InterruptedException {
+        final AtomicBoolean done = new AtomicBoolean(false);
+        class MyRunnableFuture<V> extends FutureTask<V> {
+            MyRunnableFuture(Runnable t, V r) { super(t, r); }
+            protected void done() { done.set(true); }
+        }
+        final ExecutorService e =
+            new ThreadPoolExecutor(1, 1,
+                                   30L, TimeUnit.SECONDS,
+                                   new ArrayBlockingQueue<Runnable>(1)) {
+                protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
+                    return new MyRunnableFuture<T>(t, r);
+                }};
+        final CompletionService<String> ecs =
+            new ExecutorCompletionService<>(e);
+        try (PoolCleaner cleaner = cleaner(e)) {
+            assertNull(ecs.poll());
+            Runnable r = new NoOpRunnable();
+            Future f1 = ecs.submit(r, null);
+            assertTrue("submit must return MyRunnableFuture",
+                       f1 instanceof MyRunnableFuture);
+            Future f2 = ecs.take();
+            assertSame("submit and take must return same objects", f1, f2);
+            assertTrue("completed task must have set done", done.get());
+        }
+    }
 
 }