--- jsr166/src/test/tck/AbstractExecutorServiceTest.java	2009/11/16 04:57:09	1.17
+++ jsr166/src/test/tck/AbstractExecutorServiceTest.java	2015/10/08 03:08:37	1.44
@@ -1,21 +1,37 @@
 /*
  * 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
+ * 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.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.CancellationException;
+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;
 
-public class AbstractExecutorServiceTest extends JSR166TestCase{
+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);
@@ -28,779 +44,564 @@ public class AbstractExecutorServiceTest
     static class DirectExecutorService extends AbstractExecutorService {
         public void execute(Runnable r) { r.run(); }
         public void shutdown() { shutdown = true; }
-        public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
+        public List<Runnable> shutdownNow() {
+            shutdown = true;
+            return Collections.EMPTY_LIST;
+        }
         public boolean isShutdown() { return shutdown; }
         public boolean isTerminated() { return isShutdown(); }
-        public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
+        public boolean awaitTermination(long timeout, TimeUnit unit) {
+            return isShutdown();
+        }
         private volatile boolean shutdown = false;
     }
 
     /**
      * execute(runnable) runs it to completion
      */
-    public void testExecuteRunnable() {
-        try {
-            ExecutorService e = new DirectExecutorService();
-            TrackedShortRunnable task = new TrackedShortRunnable();
-            assertFalse(task.done);
-            Future<?> future = e.submit(task);
-            future.get();
-            assertTrue(task.done);
-        }
-        catch (ExecutionException ex) {
-            unexpectedException();
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
+    public void testExecuteRunnable() throws Exception {
+        ExecutorService e = new DirectExecutorService();
+        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());
     }
 
-
     /**
      * Completed submit(callable) returns result
      */
-    public void testSubmitCallable() {
-        try {
-            ExecutorService e = new DirectExecutorService();
-            Future<String> future = e.submit(new StringTask());
-            String result = future.get();
-            assertSame(TEST_STRING, result);
-        }
-        catch (ExecutionException ex) {
-            unexpectedException();
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
+    public void testSubmitCallable() throws Exception {
+        ExecutorService e = new DirectExecutorService();
+        Future<String> future = e.submit(new StringTask());
+        String result = future.get();
+        assertSame(TEST_STRING, result);
     }
 
     /**
      * Completed submit(runnable) returns successfully
      */
-    public void testSubmitRunnable() {
-        try {
-            ExecutorService e = new DirectExecutorService();
-            Future<?> future = e.submit(new NoOpRunnable());
-            future.get();
-            assertTrue(future.isDone());
-        }
-        catch (ExecutionException ex) {
-            unexpectedException();
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
+    public void testSubmitRunnable() throws Exception {
+        ExecutorService e = new DirectExecutorService();
+        Future<?> future = e.submit(new NoOpRunnable());
+        future.get();
+        assertTrue(future.isDone());
     }
 
     /**
      * Completed submit(runnable, result) returns result
      */
-    public void testSubmitRunnable2() {
-        try {
-            ExecutorService e = new DirectExecutorService();
-            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
-            String result = future.get();
-            assertSame(TEST_STRING, result);
-        }
-        catch (ExecutionException ex) {
-            unexpectedException();
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
+    public void testSubmitRunnable2() throws Exception {
+        ExecutorService e = new DirectExecutorService();
+        Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
+        String result = future.get();
+        assertSame(TEST_STRING, result);
     }
 
-
     /**
-     * A submitted privileged action to completion
+     * A submitted privileged action runs to completion
      */
-    public void testSubmitPrivilegedAction() {
-        Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            policy.addPermission(new RuntimePermission("getContextClassLoader"));
-            policy.addPermission(new RuntimePermission("setContextClassLoader"));
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-        try {
-            ExecutorService e = new DirectExecutorService();
-            Future future = e.submit(Executors.callable(new PrivilegedAction() {
+    public void testSubmitPrivilegedAction() throws Exception {
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                ExecutorService e = new DirectExecutorService();
+                Future future = e.submit(Executors.callable(new PrivilegedAction() {
                     public Object run() {
                         return TEST_STRING;
                     }}));
 
-            Object result = future.get();
-            assertSame(TEST_STRING, result);
-        }
-        catch (ExecutionException ex) {
-            unexpectedException();
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
-        finally {
-            try {
-                Policy.setPolicy(savedPolicy);
-            } catch (AccessControlException ok) {
-                return;
-            }
-        }
+                assertSame(TEST_STRING, future.get());
+            }};
+
+        runWithPermissions(r,
+                           new RuntimePermission("getClassLoader"),
+                           new RuntimePermission("setContextClassLoader"),
+                           new RuntimePermission("modifyThread"));
     }
 
     /**
-     * A submitted a privileged exception action runs to completion
+     * A submitted privileged exception action runs to completion
      */
-    public void testSubmitPrivilegedExceptionAction() {
-        Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            policy.addPermission(new RuntimePermission("getContextClassLoader"));
-            policy.addPermission(new RuntimePermission("setContextClassLoader"));
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-
-        try {
-            ExecutorService e = new DirectExecutorService();
-            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
+    public void testSubmitPrivilegedExceptionAction() throws Exception {
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                ExecutorService e = new DirectExecutorService();
+                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                     public Object run() {
                         return TEST_STRING;
                     }}));
 
-            Object result = future.get();
-            assertSame(TEST_STRING, result);
-        }
-        catch (ExecutionException ex) {
-            unexpectedException();
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
-        finally {
-            Policy.setPolicy(savedPolicy);
-        }
+                assertSame(TEST_STRING, future.get());
+            }};
+
+        runWithPermissions(r);
     }
 
     /**
      * A submitted failed privileged exception action reports exception
      */
-    public void testSubmitFailedPrivilegedExceptionAction() {
-        Policy savedPolicy = null;
-        try {
-            savedPolicy = Policy.getPolicy();
-            AdjustablePolicy policy = new AdjustablePolicy();
-            policy.addPermission(new RuntimePermission("getContextClassLoader"));
-            policy.addPermission(new RuntimePermission("setContextClassLoader"));
-            Policy.setPolicy(policy);
-        } catch (AccessControlException ok) {
-            return;
-        }
-
-
-        try {
-            ExecutorService e = new DirectExecutorService();
-            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
+    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
+        Runnable r = new CheckedRunnable() {
+            public void realRun() throws Exception {
+                ExecutorService e = new DirectExecutorService();
+                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                     public Object run() throws Exception {
                         throw new IndexOutOfBoundsException();
                     }}));
 
-            Object result = future.get();
-            shouldThrow();
-        }
-        catch (ExecutionException success) {
-        }
-        catch (InterruptedException ex) {
-            unexpectedException();
-        }
-        finally {
-            Policy.setPolicy(savedPolicy);
-        }
+                try {
+                    future.get();
+                    shouldThrow();
+                } catch (ExecutionException success) {
+                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
+                }}};
+
+        runWithPermissions(r);
     }
 
     /**
      * execute(null runnable) throws NPE
      */
     public void testExecuteNullRunnable() {
+        ExecutorService e = new DirectExecutorService();
         try {
-            ExecutorService e = new DirectExecutorService();
-            TrackedShortRunnable task = null;
-            Future<?> future = e.submit(task);
+            e.submit((Runnable) null);
             shouldThrow();
-        }
-        catch (NullPointerException success) {
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
+        } catch (NullPointerException success) {}
     }
 
-
     /**
      * submit(null callable) throws NPE
      */
     public void testSubmitNullCallable() {
+        ExecutorService e = new DirectExecutorService();
         try {
-            ExecutorService e = new DirectExecutorService();
-            StringTask t = null;
-            Future<String> future = e.submit(t);
-            shouldThrow();
-        }
-        catch (NullPointerException success) {
-        }
-        catch (Exception ex) {
-            unexpectedException();
-        }
-    }
-
-    /**
-     * submit(runnable) throws RejectedExecutionException if
-     * executor is saturated.
-     */
-    public void testExecute1() {
-        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
-        try {
-
-            for (int i = 0; i < 5; ++i){
-                p.submit(new MediumRunnable());
-            }
-            shouldThrow();
-        } catch (RejectedExecutionException success){}
-        joinPool(p);
-    }
-
-    /**
-     * submit(callable) throws RejectedExecutionException
-     * if executor is saturated.
-     */
-    public void testExecute2() {
-         ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, 60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1));
-        try {
-            for (int i = 0; i < 5; ++i) {
-                p.submit(new SmallCallable());
-            }
+            e.submit((Callable) null);
             shouldThrow();
-        } catch (RejectedExecutionException e){}
-        joinPool(p);
-    }
-
-
-    /**
-     *  Blocking on submit(callable) throws InterruptedException if
-     *  caller interrupted.
-     */
-    public void testInterruptedSubmit() {
-        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    try {
-                        p.submit(new Callable<Object>() {
-                                public Object call() {
-                                    try {
-                                        Thread.sleep(MEDIUM_DELAY_MS);
-                                        shouldThrow();
-                                    } catch (InterruptedException e){
-                                    }
-                                    return null;
-                                }
-                            }).get();
-                    } catch (InterruptedException success){
-                    } catch (Exception e) {
-                        unexpectedException();
-                    }
-
-                }
-            });
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
-            t.interrupt();
-        } catch (Exception e){
-            unexpectedException();
-        }
-        joinPool(p);
+        } catch (NullPointerException success) {}
     }
 
     /**
-     *  get of submitted callable throws Exception if callable
-     *  interrupted
+     * submit(callable).get() throws InterruptedException if interrupted
      */
-    public void testSubmitIE() {
-        final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
-
-        final Callable c = new Callable() {
-                public Object call() {
-                    try {
-                        p.submit(new SmallCallable()).get();
-                        shouldThrow();
-                    } catch (InterruptedException e){}
-                    catch (RejectedExecutionException e2){}
-                    catch (ExecutionException e3){}
-                    return Boolean.TRUE;
-                }
-            };
-
+    public void testInterruptedSubmit() throws InterruptedException {
+        final CountDownLatch submitted    = new CountDownLatch(1);
+        final CountDownLatch quittingTime = new CountDownLatch(1);
+        final Callable<Void> awaiter = new CheckedCallable<Void>() {
+            public Void realCall() throws InterruptedException {
+                assertTrue(quittingTime.await(2*LONG_DELAY_MS, MILLISECONDS));
+                return null;
+            }};
+        final ExecutorService p
+            = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS,
+                                     new ArrayBlockingQueue<Runnable>(10));
+        try (PoolCleaner cleaner = cleaner(p, quittingTime)) {
+            Thread t = newStartedThread(new CheckedInterruptedRunnable() {
+                public void realRun() throws Exception {
+                    Future<Void> future = p.submit(awaiter);
+                    submitted.countDown();
+                    future.get();
+                }});
 
-
-        Thread t = new Thread(new Runnable() {
-                public void run() {
-                    try {
-                        c.call();
-                    } catch (Exception e){}
-                }
-          });
-        try {
-            t.start();
-            Thread.sleep(SHORT_DELAY_MS);
+            await(submitted);
             t.interrupt();
-            t.join();
-        } catch (InterruptedException e){
-            unexpectedException();
+            awaitTermination(t);
         }
-
-        joinPool(p);
     }
 
     /**
-     *  get of submit(callable) throws ExecutionException if callable
-     *  throws exception
+     * get of submit(callable) throws ExecutionException if callable
+     * throws exception
      */
-    public void testSubmitEE() {
-        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
-
-        try {
+    public void testSubmitEE() throws InterruptedException {
+        final ThreadPoolExecutor p =
+            new ThreadPoolExecutor(1, 1,
+                                   60, TimeUnit.SECONDS,
+                                   new ArrayBlockingQueue<Runnable>(10));
+        try (PoolCleaner cleaner = cleaner(p)) {
             Callable c = new Callable() {
-                    public Object call() {
-                        int i = 5/0;
-                        return Boolean.TRUE;
-                    }
-                };
-
-            for (int i =0; i < 5; i++){
+                public Object call() { throw new ArithmeticException(); }};
+            try {
                 p.submit(c).get();
+                shouldThrow();
+            } catch (ExecutionException success) {
+                assertTrue(success.getCause() instanceof ArithmeticException);
             }
-
-            shouldThrow();
-        }
-        catch (ExecutionException success){
-        } catch (Exception e) {
-            unexpectedException();
         }
-        joinPool(p);
     }
 
     /**
      * invokeAny(null) throws NPE
      */
-    public void testInvokeAny1() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAny(null);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testInvokeAny1() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            try {
+                e.invokeAny(null);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * invokeAny(empty collection) throws IAE
      */
-    public void testInvokeAny2() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAny(new ArrayList<Callable<String>>());
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testInvokeAny2() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            try {
+                e.invokeAny(new ArrayList<Callable<String>>());
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
         }
     }
 
     /**
      * invokeAny(c) throws NPE if c has null elements
      */
-    public void testInvokeAny3() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
-            l.add(new StringTask());
+    public void testInvokeAny3() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<Long>> l = new ArrayList<Callable<Long>>();
+            l.add(new Callable<Long>() {
+                      public Long call() { throw new ArithmeticException(); }});
             l.add(null);
-            e.invokeAny(l);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAny(l);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * invokeAny(c) throws ExecutionException if no task in c completes
      */
-    public void testInvokeAny4() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testInvokeAny4() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new NPETask());
-            e.invokeAny(l);
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAny(l);
+                shouldThrow();
+            } catch (ExecutionException success) {
+                assertTrue(success.getCause() instanceof NullPointerException);
+            }
         }
     }
 
     /**
      * invokeAny(c) returns result of some task in c if at least one completes
      */
-    public void testInvokeAny5() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testInvokeAny5() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
             l.add(new StringTask());
             String result = e.invokeAny(l);
             assertSame(TEST_STRING, result);
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
         }
     }
 
     /**
      * invokeAll(null) throws NPE
      */
-    public void testInvokeAll1() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAll(null);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testInvokeAll1() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            try {
+                e.invokeAll(null);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * invokeAll(empty collection) returns empty collection
      */
-    public void testInvokeAll2() {
-        ExecutorService e = new DirectExecutorService();
-        try {
+    public void testInvokeAll2() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
             List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
             assertTrue(r.isEmpty());
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
         }
     }
 
     /**
      * invokeAll(c) throws NPE if c has null elements
      */
-    public void testInvokeAll3() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testInvokeAll3() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
             l.add(null);
-            e.invokeAll(l);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAll(l);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * get of returned element of invokeAll(c) throws exception on failed task
      */
-    public void testInvokeAll4() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testInvokeAll4() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new NPETask());
-            List<Future<String>> result = e.invokeAll(l);
-            assertEquals(1, result.size());
-            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
-                it.next().get();
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            List<Future<String>> futures = e.invokeAll(l);
+            assertEquals(1, futures.size());
+            try {
+                futures.get(0).get();
+                shouldThrow();
+            } catch (ExecutionException success) {
+                assertTrue(success.getCause() instanceof NullPointerException);
+            }
         }
     }
 
     /**
      * invokeAll(c) returns results of all completed tasks in c
      */
-    public void testInvokeAll5() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testInvokeAll5() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
             l.add(new StringTask());
-            List<Future<String>> result = e.invokeAll(l);
-            assertEquals(2, result.size());
-            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
-                assertSame(TEST_STRING, it.next().get());
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            List<Future<String>> futures = e.invokeAll(l);
+            assertEquals(2, futures.size());
+            for (Future<String> future : futures)
+                assertSame(TEST_STRING, future.get());
         }
     }
 
-
     /**
      * timed invokeAny(null) throws NPE
      */
-    public void testTimedInvokeAny1() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testTimedInvokeAny1() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            try {
+                e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * timed invokeAny(null time unit) throws NPE
      */
-    public void testTimedInvokeAnyNullTimeUnit() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAnyNullTimeUnit() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
-            e.invokeAny(l, MEDIUM_DELAY_MS, null);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAny(l, MEDIUM_DELAY_MS, null);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * timed invokeAny(empty collection) throws IAE
      */
-    public void testTimedInvokeAny2() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-        } catch (IllegalArgumentException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testTimedInvokeAny2() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            try {
+                e.invokeAny(new ArrayList<Callable<String>>(),
+                            MEDIUM_DELAY_MS, MILLISECONDS);
+                shouldThrow();
+            } catch (IllegalArgumentException success) {}
         }
     }
 
     /**
      * timed invokeAny(c) throws NPE if c has null elements
      */
-    public void testTimedInvokeAny3() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
-            l.add(new StringTask());
+    public void testTimedInvokeAny3() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<Long>> l = new ArrayList<Callable<Long>>();
+            l.add(new Callable<Long>() {
+                      public Long call() { throw new ArithmeticException(); }});
             l.add(null);
-            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            ex.printStackTrace();
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * timed invokeAny(c) throws ExecutionException if no task completes
      */
-    public void testTimedInvokeAny4() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAny4() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            long startTime = System.nanoTime();
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new NPETask());
-            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
+                shouldThrow();
+            } catch (ExecutionException success) {
+                assertTrue(success.getCause() instanceof NullPointerException);
+            }
+            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         }
     }
 
     /**
      * timed invokeAny(c) returns result of some task in c
      */
-    public void testTimedInvokeAny5() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAny5() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            long startTime = System.nanoTime();
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
             l.add(new StringTask());
-            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
+            String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
             assertSame(TEST_STRING, result);
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
         }
     }
 
     /**
      * timed invokeAll(null) throws NPE
      */
-    public void testTimedInvokeAll1() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testTimedInvokeAll1() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            try {
+                e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * timed invokeAll(null time unit) throws NPE
      */
-    public void testTimedInvokeAllNullTimeUnit() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
-            e.invokeAll(l, MEDIUM_DELAY_MS, null);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAll(l, MEDIUM_DELAY_MS, null);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * timed invokeAll(empty collection) returns empty collection
      */
-    public void testTimedInvokeAll2() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
+    public void testTimedInvokeAll2() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
             assertTrue(r.isEmpty());
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
         }
     }
 
     /**
      * timed invokeAll(c) throws NPE if c has null elements
      */
-    public void testTimedInvokeAll3() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAll3() throws InterruptedException {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
             l.add(null);
-            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-        } catch (NullPointerException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            try {
+                e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
+                shouldThrow();
+            } catch (NullPointerException success) {}
         }
     }
 
     /**
      * get of returned element of invokeAll(c) throws exception on failed task
      */
-    public void testTimedInvokeAll4() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAll4() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new NPETask());
-            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-            assertEquals(1, result.size());
-            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
-                it.next().get();
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            List<Future<String>> futures =
+                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
+            assertEquals(1, futures.size());
+            try {
+                futures.get(0).get();
+                shouldThrow();
+            } catch (ExecutionException success) {
+                assertTrue(success.getCause() instanceof NullPointerException);
+            }
         }
     }
 
     /**
      * timed invokeAll(c) returns results of all completed tasks in c
      */
-    public void testTimedInvokeAll5() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
+    public void testTimedInvokeAll5() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            List<Callable<String>> l = new ArrayList<Callable<String>>();
             l.add(new StringTask());
             l.add(new StringTask());
-            List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
-            assertEquals(2, result.size());
-            for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
-                assertSame(TEST_STRING, it.next().get());
-        } catch (ExecutionException success) {
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+            List<Future<String>> futures =
+                e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
+            assertEquals(2, futures.size());
+            for (Future<String> future : futures)
+                assertSame(TEST_STRING, future.get());
         }
     }
 
     /**
      * timed invokeAll cancels tasks not completed by timeout
      */
-    public void testTimedInvokeAll6() {
-        ExecutorService e = new DirectExecutorService();
-        try {
-            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
-            l.add(new StringTask());
-            l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
-            l.add(new StringTask());
-            List<Future<String>> result = e.invokeAll(l, SMALL_DELAY_MS, TimeUnit.MILLISECONDS);
-            assertEquals(3, result.size());
-            Iterator<Future<String>> it = result.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());
-            assertTrue(f3.isDone());
-            assertTrue(f3.isCancelled());
-        } catch (Exception ex) {
-            unexpectedException();
-        } finally {
-            joinPool(e);
+    public void testTimedInvokeAll6() throws Exception {
+        final ExecutorService e = new DirectExecutorService();
+        try (PoolCleaner cleaner = cleaner(e)) {
+            for (long timeout = timeoutMillis();;) {
+                List<Callable<String>> tasks = new ArrayList<>();
+                tasks.add(new StringTask("0"));
+                tasks.add(Executors.callable(possiblyInterruptedRunnable(timeout),
+                                             TEST_STRING));
+                tasks.add(new StringTask("2"));
+                long startTime = System.nanoTime();
+                List<Future<String>> futures =
+                    e.invokeAll(tasks, timeout, MILLISECONDS);
+                assertEquals(tasks.size(), futures.size());
+                assertTrue(millisElapsedSince(startTime) >= timeout);
+                for (Future future : futures)
+                    assertTrue(future.isDone());
+                try {
+                    assertEquals("0", futures.get(0).get());
+                    assertEquals(TEST_STRING, futures.get(1).get());
+                } catch (CancellationException retryWithLongerTimeout) {
+                    // unusual delay before starting second task
+                    timeout *= 2;
+                    if (timeout >= LONG_DELAY_MS / 2)
+                        fail("expected exactly one task to be cancelled");
+                    continue;
+                }
+                assertTrue(futures.get(2).isCancelled());
+                break;
+            }
         }
     }