--- jsr166/src/test/tck/AbstractExecutorServiceTest.java	2011/05/28 22:33:35	1.31
+++ jsr166/src/test/tck/AbstractExecutorServiceTest.java	2015/04/25 04:55:30	1.37
@@ -6,16 +6,31 @@
  * Pat Fisher, Mike Judd.
  */
 
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.math.BigInteger;
-import java.security.*;
+
+import java.security.PrivilegedAction;
+import java.security.PrivilegedExceptionAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
 
 public class AbstractExecutorServiceTest extends JSR166TestCase {
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
     public static Test suite() {
         return new TestSuite(AbstractExecutorServiceTest.class);
@@ -45,11 +60,16 @@ public class AbstractExecutorServiceTest
      */
     public void testExecuteRunnable() throws Exception {
         ExecutorService e = new DirectExecutorService();
-        TrackedShortRunnable task = new TrackedShortRunnable();
-        assertFalse(task.done);
-        Future<?> future = e.submit(task);
-        future.get();
-        assertTrue(task.done);
+        final AtomicBoolean done = new AtomicBoolean(false);
+        Future<?> future = e.submit(new CheckedRunnable() {
+            public void realRun() {
+                done.set(true);
+            }});
+        assertNull(future.get());
+        assertNull(future.get(0, MILLISECONDS));
+        assertTrue(done.get());
+        assertTrue(future.isDone());
+        assertFalse(future.isCancelled());
     }
 
     /**
@@ -147,8 +167,8 @@ public class AbstractExecutorServiceTest
      * execute(null runnable) throws NPE
      */
     public void testExecuteNullRunnable() {
+        ExecutorService e = new DirectExecutorService();
         try {
-            ExecutorService e = new DirectExecutorService();
             e.submit((Runnable) null);
             shouldThrow();
         } catch (NullPointerException success) {}
@@ -158,8 +178,8 @@ public class AbstractExecutorServiceTest
      * submit(null callable) throws NPE
      */
     public void testSubmitNullCallable() {
+        ExecutorService e = new DirectExecutorService();
         try {
-            ExecutorService e = new DirectExecutorService();
             e.submit((Callable) null);
             shouldThrow();
         } catch (NullPointerException success) {}
@@ -207,7 +227,7 @@ public class AbstractExecutorServiceTest
                                    new ArrayBlockingQueue<Runnable>(10));
 
         Callable c = new Callable() {
-            public Object call() { return 5/0; }};
+            public Object call() { throw new ArithmeticException(); }};
 
         try {
             p.submit(c).get();
@@ -251,9 +271,9 @@ public class AbstractExecutorServiceTest
      */
     public void testInvokeAny3() throws Exception {
         ExecutorService e = new DirectExecutorService();
-        List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
-        l.add(new Callable<Integer>() {
-                  public Integer call() { return 5/0; }});
+        List<Callable<Long>> l = new ArrayList<Callable<Long>>();
+        l.add(new Callable<Long>() {
+            public Long call() { throw new ArithmeticException(); }});
         l.add(null);
         try {
             e.invokeAny(l);
@@ -429,9 +449,9 @@ public class AbstractExecutorServiceTest
      */
     public void testTimedInvokeAny3() throws Exception {
         ExecutorService e = new DirectExecutorService();
-        List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
-        l.add(new Callable<Integer>() {
-                  public Integer call() { return 5/0; }});
+        List<Callable<Long>> l = new ArrayList<Callable<Long>>();
+        l.add(new Callable<Long>() {
+            public Long call() { throw new ArithmeticException(); }});
         l.add(null);
         try {
             e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
@@ -588,17 +608,12 @@ public class AbstractExecutorServiceTest
             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());
-            assertFalse(f1.isCancelled());
-            assertTrue(f2.isDone());
-            assertFalse(f2.isCancelled());
-            assertTrue(f3.isDone());
-            assertTrue(f3.isCancelled());
+            assertEquals(l.size(), futures.size());
+            for (Future future : futures)
+                assertTrue(future.isDone());
+            assertFalse(futures.get(0).isCancelled());
+            assertFalse(futures.get(1).isCancelled());
+            assertTrue(futures.get(2).isCancelled());
         } finally {
             joinPool(e);
         }