--- jsr166/src/test/tck/ExecutorCompletionServiceTest.java	2003/12/23 19:40:24	1.1
+++ jsr166/src/test/tck/ExecutorCompletionServiceTest.java	2010/08/25 01:44:48	1.12
@@ -1,20 +1,23 @@
 /*
- * Written by members of JCP JSR-166 Expert Group and released to the
- * public domain. Use, modify, and redistribute this code in any way
- * without acknowledgement. Other contributors include Andrew Wright,
- * Jeffrey Hayes, Pat Fischer, Mike Judd.
+ * 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.
  */
 
 
 import junit.framework.*;
 import java.util.*;
 import java.util.concurrent.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import java.util.concurrent.atomic.*;
 import java.math.BigInteger;
 import java.security.*;
 
-public class ExecutorCompletionServiceTest extends JSR166TestCase{
+public class ExecutorCompletionServiceTest extends JSR166TestCase {
     public static void main(String[] args) {
-        junit.textui.TestRunner.run (suite());  
+        junit.textui.TestRunner.run(suite());
     }
     public static Test suite() {
         return new TestSuite(ExecutorCompletionServiceTest.class);
@@ -23,30 +26,28 @@ public class ExecutorCompletionServiceTe
 
     /**
      * Creating a new ECS with null Executor throw NPE
-     */ 
+     */
     public void testConstructorNPE() {
         try {
             ExecutorCompletionService ecs = 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);
             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);
@@ -62,7 +63,7 @@ public class ExecutorCompletionServiceTe
 
     /**
      * Submitting a null runnable throws NPE
-     */ 
+     */
     public void testSubmitNPE2() {
         ExecutorService e = Executors.newCachedThreadPool();
         ExecutorCompletionService ecs = new ExecutorCompletionService(e);
@@ -78,17 +79,15 @@ public class ExecutorCompletionServiceTe
 
     /**
      * A taken submitted task is completed
-     */ 
-    public void testTake() {
+     */
+    public void testTake() throws InterruptedException {
         ExecutorService e = Executors.newCachedThreadPool();
         ExecutorCompletionService ecs = new ExecutorCompletionService(e);
         try {
             Callable c = new StringTask();
             ecs.submit(c);
             Future f = ecs.take();
-            assert(f.isDone());
-        } catch (Exception ex) {
-            unexpectedException();
+            assertTrue(f.isDone());
         } finally {
             joinPool(e);
         }
@@ -96,8 +95,8 @@ public class ExecutorCompletionServiceTe
 
     /**
      * Take returns the same future object returned by submit
-     */ 
-    public void testTake2() {
+     */
+    public void testTake2() throws InterruptedException {
         ExecutorService e = Executors.newCachedThreadPool();
         ExecutorCompletionService ecs = new ExecutorCompletionService(e);
         try {
@@ -105,8 +104,6 @@ public class ExecutorCompletionServiceTe
             Future f1 = ecs.submit(c);
             Future f2 = ecs.take();
             assertSame(f1, f2);
-        } catch (Exception ex) {
-            unexpectedException();
         } finally {
             joinPool(e);
         }
@@ -114,8 +111,8 @@ public class ExecutorCompletionServiceTe
 
     /**
      * If poll returns non-null, the returned task is completed
-     */ 
-    public void testPoll1() {
+     */
+    public void testPoll1() throws InterruptedException {
         ExecutorService e = Executors.newCachedThreadPool();
         ExecutorCompletionService ecs = new ExecutorCompletionService(e);
         try {
@@ -126,12 +123,10 @@ public class ExecutorCompletionServiceTe
             for (;;) {
                 Future f = ecs.poll();
                 if (f != null) {
-                    assert(f.isDone());
+                    assertTrue(f.isDone());
                     break;
                 }
             }
-        } catch (Exception ex) {
-            unexpectedException();
         } finally {
             joinPool(e);
         }
@@ -139,19 +134,81 @@ public class ExecutorCompletionServiceTe
 
     /**
      * If timed poll returns non-null, the returned task is completed
-     */ 
-    public void testPoll2() {
+     */
+    public void testPoll2() throws InterruptedException {
         ExecutorService e = Executors.newCachedThreadPool();
         ExecutorCompletionService ecs = new ExecutorCompletionService(e);
         try {
             assertNull(ecs.poll());
             Callable c = new StringTask();
             ecs.submit(c);
-            Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-            if (f != null) 
-                assert(f.isDone());
-        } catch (Exception ex) {
-            unexpectedException();
+            Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
+            if (f != null)
+                assertTrue(f.isDone());
+        } 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); }
+        }
+        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());
+        } finally {
+            joinPool(e);
+        }
+    }
+
+    /**
+     * 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); }
+        }
+        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());
+            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());
         } finally {
             joinPool(e);
         }