--- jsr166/src/test/tck/ForkJoinPoolTest.java	2011/05/29 07:01:17	1.42
+++ jsr166/src/test/tck/ForkJoinPoolTest.java	2013/05/20 16:46:23	1.50
@@ -25,6 +25,7 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.locks.ReentrantLock;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
 import java.security.AccessControlException;
 import java.security.Policy;
 import java.security.PrivilegedAction;
@@ -39,7 +40,7 @@ public class ForkJoinPoolTest extends JS
         return new TestSuite(ForkJoinPoolTest.class);
     }
 
-    /**
+    /*
      * Testing coverage notes:
      *
      * 1. shutdown and related methods are tested via super.joinPool.
@@ -226,6 +227,33 @@ public class ForkJoinPoolTest extends JS
     }
 
     /**
+     * awaitTermination on a non-shutdown pool times out
+     */
+    public void testAwaitTermination_timesOut() throws InterruptedException {
+        ForkJoinPool p = new ForkJoinPool(1);
+        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());
+    }
+
+    /**
      * setUncaughtExceptionHandler changes handler for uncaught exceptions.
      *
      * Additionally tests: Overriding ForkJoinWorkerThread.onStart
@@ -242,8 +270,11 @@ public class ForkJoinPoolTest extends JS
                                           eh, false);
         try {
             assertSame(eh, p.getUncaughtExceptionHandler());
-            p.execute(new FibTask(8));
-            assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
+            try {
+                p.execute(new FibTask(8));
+                assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
+            } catch (RejectedExecutionException ok) {
+            }
         } finally {
             p.shutdownNow(); // failure might have prevented processing task
             joinPool(p);
@@ -256,7 +287,7 @@ public class ForkJoinPoolTest extends JS
      * the task has completed successfully, and construction
      * parameters continue to hold
      */
-    public void testisQuiescent() throws Exception {
+    public void testIsQuiescent() throws Exception {
         ForkJoinPool p = new ForkJoinPool(2);
         try {
             assertTrue(p.isQuiescent());
@@ -452,35 +483,39 @@ public class ForkJoinPoolTest extends JS
      * A submitted privileged action runs to completion
      */
     public void testSubmitPrivilegedAction() throws Exception {
+        final Callable callable = Executors.callable(new PrivilegedAction() {
+                public Object run() { return TEST_STRING; }});
         Runnable r = new CheckedRunnable() {
-            public void realRun() throws Exception {
-                ExecutorService e = new ForkJoinPool(1);
-                Future future = e.submit(Executors.callable(new PrivilegedAction() {
-                    public Object run() {
-                        return TEST_STRING;
-                    }}));
-
+        public void realRun() throws Exception {
+            ExecutorService e = new ForkJoinPool(1);
+            try {
+                Future future = e.submit(callable);
                 assertSame(TEST_STRING, future.get());
-            }};
+            } finally {
+                joinPool(e);
+            }
+        }};
 
-        runWithPermissions(r,
-                           new RuntimePermission("modifyThread"));
+        runWithPermissions(r, new RuntimePermission("modifyThread"));
     }
 
     /**
      * A submitted privileged exception action runs to completion
      */
     public void testSubmitPrivilegedExceptionAction() throws Exception {
+        final Callable callable =
+            Executors.callable(new PrivilegedExceptionAction() {
+                public Object run() { return TEST_STRING; }});
         Runnable r = new CheckedRunnable() {
-            public void realRun() throws Exception {
-                ExecutorService e = new ForkJoinPool(1);
-                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
-                    public Object run() {
-                        return TEST_STRING;
-                    }}));
-
+        public void realRun() throws Exception {
+            ExecutorService e = new ForkJoinPool(1);
+            try {
+                Future future = e.submit(callable);
                 assertSame(TEST_STRING, future.get());
-            }};
+            } finally {
+                joinPool(e);
+            }
+        }};
 
         runWithPermissions(r, new RuntimePermission("modifyThread"));
     }
@@ -489,20 +524,24 @@ public class ForkJoinPoolTest extends JS
      * A submitted failed privileged exception action reports exception
      */
     public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
+        final Callable callable =
+            Executors.callable(new PrivilegedExceptionAction() {
+                public Object run() { throw new IndexOutOfBoundsException(); }});
         Runnable r = new CheckedRunnable() {
-            public void realRun() throws Exception {
-                ExecutorService e = new ForkJoinPool(1);
-                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
-                    public Object run() throws Exception {
-                        throw new IndexOutOfBoundsException();
-                    }}));
-
+        public void realRun() throws Exception {
+            ExecutorService e = new ForkJoinPool(1);
+            try {
+                Future future = e.submit(callable);
                 try {
                     future.get();
                     shouldThrow();
                 } catch (ExecutionException success) {
                     assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
-                }}};
+                }
+            } finally {
+                joinPool(e);
+            }
+        }};
 
         runWithPermissions(r, new RuntimePermission("modifyThread"));
     }
@@ -572,10 +611,8 @@ public class ForkJoinPoolTest extends JS
         ForkJoinPool p = new ForkJoinPool(1);
         try {
             p.submit(new Callable() {
-                public Object call() {
-                    int i = 5/0;
-                    return Boolean.TRUE;
-                }}).get();
+                public Object call() { throw new ArithmeticException(); }})
+                .get();
             shouldThrow();
         } catch (ExecutionException success) {
             assertTrue(success.getCause() instanceof ArithmeticException);