--- jsr166/src/test/tck/ForkJoinPoolTest.java 2010/01/05 02:08:37 1.17 +++ jsr166/src/test/tck/ForkJoinPoolTest.java 2015/10/08 03:08:37 1.68 @@ -1,26 +1,45 @@ /* * 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/ */ - -import junit.framework.*; -import java.util.*; -import java.util.concurrent.*; import static java.util.concurrent.TimeUnit.MILLISECONDS; -import java.util.concurrent.locks.*; -import java.security.*; +import static java.util.concurrent.TimeUnit.NANOSECONDS; + +import java.security.PrivilegedAction; +import java.security.PrivilegedExceptionAction; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +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.ForkJoinPool; +import java.util.concurrent.ForkJoinTask; +import java.util.concurrent.ForkJoinWorkerThread; +import java.util.concurrent.Future; +import java.util.concurrent.RecursiveTask; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.locks.ReentrantLock; + +import junit.framework.AssertionFailedError; +import junit.framework.Test; +import junit.framework.TestSuite; public class ForkJoinPoolTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run (suite()); + main(suite(), args); } + public static Test suite() { return new TestSuite(ForkJoinPoolTest.class); } - /** + /* * Testing coverage notes: * * 1. shutdown and related methods are tested via super.joinPool. @@ -39,21 +58,23 @@ public class ForkJoinPoolTest extends JS // Some classes to test extension and factory methods static class MyHandler implements Thread.UncaughtExceptionHandler { - int catches = 0; + volatile int catches = 0; public void uncaughtException(Thread t, Throwable e) { ++catches; } } + static class MyError extends Error {} + // to test handlers static class FailingFJWSubclass extends ForkJoinWorkerThread { public FailingFJWSubclass(ForkJoinPool p) { super(p) ; } - protected void onStart() { throw new Error(); } + protected void onStart() { super.onStart(); throw new MyError(); } } static class FailingThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory { - int calls = 0; + volatile int calls = 0; public ForkJoinWorkerThread newThread(ForkJoinPool p) { if (++calls > 1) return null; return new FailingFJWSubclass(p); @@ -88,7 +109,7 @@ public class ForkJoinPoolTest extends JS static final class FibTask extends RecursiveTask { final int number; FibTask(int n) { number = n; } - public Integer compute() { + protected Integer compute() { int n = number; if (n <= 1) return n; @@ -116,7 +137,7 @@ public class ForkJoinPoolTest extends JS this.locker = locker; this.lock = lock; } - public Integer compute() { + protected Integer compute() { int n; LockingFibTask f1 = null; LockingFibTask f2 = null; @@ -142,24 +163,19 @@ public class ForkJoinPoolTest extends JS * tasks, and quiescent running state. */ public void testDefaultInitialState() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - assertTrue(p.getFactory() == - ForkJoinPool.defaultForkJoinWorkerThreadFactory); - assertTrue(p.isQuiescent()); - assertTrue(p.getMaintainsParallelism()); + ForkJoinPool p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p)) { + assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, + p.getFactory()); assertFalse(p.getAsyncMode()); - assertTrue(p.getActiveThreadCount() == 0); - assertTrue(p.getStealCount() == 0); - assertTrue(p.getQueuedTaskCount() == 0); - assertTrue(p.getQueuedSubmissionCount() == 0); + assertEquals(0, p.getActiveThreadCount()); + assertEquals(0, p.getStealCount()); + assertEquals(0, p.getQueuedTaskCount()); + assertEquals(0, p.getQueuedSubmissionCount()); assertFalse(p.hasQueuedSubmissions()); assertFalse(p.isShutdown()); assertFalse(p.isTerminating()); assertFalse(p.isTerminated()); - } finally { - joinPool(p); } } @@ -178,53 +194,18 @@ public class ForkJoinPoolTest extends JS */ public void testConstructor2() { try { - new ForkJoinPool(1, null); + new ForkJoinPool(1, null, null, false); shouldThrow(); } catch (NullPointerException success) {} } - /** * getParallelism returns size set in constructor */ public void testGetParallelism() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - assertTrue(p.getParallelism() == 1); - } finally { - joinPool(p); - } - } - - /** - * setParallelism changes reported parallelism level. - */ - public void testSetParallelism() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - assertTrue(p.getParallelism() == 1); - p.setParallelism(2); - assertTrue(p.getParallelism() == 2); - } finally { - joinPool(p); - } - } - - /** - * setParallelism with argument <= 0 throws exception - */ - public void testSetParallelism2() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - assertTrue(p.getParallelism() == 1); - p.setParallelism(-2); - shouldThrow(); - } catch (IllegalArgumentException success) { - } finally { - joinPool(p); + ForkJoinPool p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p)) { + assertEquals(1, p.getParallelism()); } } @@ -232,74 +213,40 @@ public class ForkJoinPoolTest extends JS * getPoolSize returns number of started workers. */ public void testGetPoolSize() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - assertTrue(p.getPoolSize() == 0); + ForkJoinPool p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p)) { + assertEquals(0, p.getActiveThreadCount()); Future future = p.submit(new StringTask()); - assertTrue(p.getPoolSize() == 1); - - } finally { - joinPool(p); - } - } - - /** - * setMaximumPoolSize changes size reported by getMaximumPoolSize. - */ - public void testSetMaximumPoolSize() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setMaximumPoolSize(2); - assertTrue(p.getMaximumPoolSize() == 2); - } finally { - joinPool(p); - } - } - - /** - * setMaximumPoolSize with argument <= 0 throws exception - */ - public void testSetMaximumPoolSize2() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setMaximumPoolSize(-2); - shouldThrow(); - } catch (IllegalArgumentException success) { - } finally { - joinPool(p); - } - } - - /** - * setMaintainsParallelism changes policy reported by - * getMaintainsParallelism. - */ - public void testSetMaintainsParallelism() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setMaintainsParallelism(false); - assertFalse(p.getMaintainsParallelism()); - } finally { - joinPool(p); + assertEquals(1, p.getPoolSize()); } } /** - * setAsyncMode changes policy reported by - * getAsyncMode. + * awaitTermination on a non-shutdown pool times out */ - public void testSetAsyncMode() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setAsyncMode(true); - assertTrue(p.getAsyncMode()); - } finally { - joinPool(p); + public void testAwaitTermination_timesOut() throws InterruptedException { + ForkJoinPool p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p)) { + 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()); } } @@ -310,60 +257,63 @@ public class ForkJoinPoolTest extends JS * performs its defined action */ public void testSetUncaughtExceptionHandler() throws InterruptedException { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1, new FailingThreadFactory()); - MyHandler eh = new MyHandler(); - p.setUncaughtExceptionHandler(eh); - assertEquals(eh, p.getUncaughtExceptionHandler()); - p.execute(new FailingTask()); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(eh.catches > 0); - } finally { - joinPool(p); + final CountDownLatch uehInvoked = new CountDownLatch(1); + final Thread.UncaughtExceptionHandler ueh = + new Thread.UncaughtExceptionHandler() { + public void uncaughtException(Thread t, Throwable e) { + threadAssertTrue(e instanceof MyError); + threadAssertTrue(t instanceof FailingFJWSubclass); + uehInvoked.countDown(); + }}; + ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(), + ueh, false); + try (PoolCleaner cleaner = cleaner(p)) { + assertSame(ueh, p.getUncaughtExceptionHandler()); + try { + p.execute(new FibTask(8)); + await(uehInvoked); + } finally { + p.shutdownNow(); // failure might have prevented processing task + } } } /** - * setUncaughtExceptionHandler of null removes handler - */ - public void testSetUncaughtExceptionHandler2() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setUncaughtExceptionHandler(null); - assertNull(p.getUncaughtExceptionHandler()); - } finally { - joinPool(p); - } - } - + * After invoking a single task, isQuiescent eventually becomes + * true, at which time queues are empty, threads are not active, + * the task has completed successfully, and construction + * parameters continue to hold + */ + public void testIsQuiescent() throws Exception { + ForkJoinPool p = new ForkJoinPool(2); + try (PoolCleaner cleaner = cleaner(p)) { + assertTrue(p.isQuiescent()); + long startTime = System.nanoTime(); + FibTask f = new FibTask(20); + p.invoke(f); + assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, + p.getFactory()); + while (! p.isQuiescent()) { + if (millisElapsedSince(startTime) > LONG_DELAY_MS) + throw new AssertionFailedError("timed out"); + assertFalse(p.getAsyncMode()); + assertFalse(p.isShutdown()); + assertFalse(p.isTerminating()); + assertFalse(p.isTerminated()); + Thread.yield(); + } - /** - * After invoking a single task, isQuiescent is true, - * queues are empty, threads are not active, and - * construction parameters continue to hold - */ - public void testisQuiescent() throws InterruptedException { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(2); - p.invoke(new FibTask(20)); - assertTrue(p.getFactory() == - ForkJoinPool.defaultForkJoinWorkerThreadFactory); - Thread.sleep(MEDIUM_DELAY_MS); assertTrue(p.isQuiescent()); - assertTrue(p.getMaintainsParallelism()); assertFalse(p.getAsyncMode()); - assertTrue(p.getActiveThreadCount() == 0); - assertTrue(p.getQueuedTaskCount() == 0); - assertTrue(p.getQueuedSubmissionCount() == 0); + assertEquals(0, p.getActiveThreadCount()); + assertEquals(0, p.getQueuedTaskCount()); + assertEquals(0, p.getQueuedSubmissionCount()); assertFalse(p.hasQueuedSubmissions()); assertFalse(p.isShutdown()); assertFalse(p.isTerminating()); assertFalse(p.isTerminated()); - } finally { - joinPool(p); + assertTrue(f.isDone()); + assertEquals(6765, (int) f.get()); } } @@ -371,14 +321,10 @@ public class ForkJoinPoolTest extends JS * Completed submit(ForkJoinTask) returns result */ public void testSubmitForkJoinTask() throws Throwable { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); + ForkJoinPool p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p)) { ForkJoinTask f = p.submit(new FibTask(8)); - int r = f.get(); - assertTrue(r == 21); - } finally { - joinPool(p); + assertEquals(21, (int) f.get()); } } @@ -386,16 +332,14 @@ public class ForkJoinPoolTest extends JS * A task submitted after shutdown is rejected */ public void testSubmitAfterShutdown() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); + ForkJoinPool p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p)) { p.shutdown(); assertTrue(p.isShutdown()); - ForkJoinTask f = p.submit(new FibTask(8)); - shouldThrow(); - } catch (RejectedExecutionException success) { - } finally { - joinPool(p); + try { + ForkJoinTask f = p.submit(new FibTask(8)); + shouldThrow(); + } catch (RejectedExecutionException success) {} } } @@ -403,16 +347,13 @@ public class ForkJoinPoolTest extends JS * Pool maintains parallelism when using ManagedBlocker */ public void testBlockingForkJoinTask() throws Throwable { - ForkJoinPool p = null; + ForkJoinPool p = new ForkJoinPool(4); try { - p = new ForkJoinPool(4); ReentrantLock lock = new ReentrantLock(); ManagedLocker locker = new ManagedLocker(lock); - ForkJoinTask f = new LockingFibTask(30, locker, lock); + ForkJoinTask f = new LockingFibTask(20, locker, lock); p.execute(f); - assertTrue(p.getPoolSize() >= 4); - int r = f.get(); - assertTrue(r == 832040); + assertEquals(6765, (int) f.get()); } finally { p.shutdownNow(); // don't wait out shutdown } @@ -422,17 +363,16 @@ public class ForkJoinPoolTest extends JS * pollSubmission returns unexecuted submitted task, if present */ public void testPollSubmission() { - SubFJP p = null; - try { - p = new SubFJP(); - ForkJoinTask a = p.submit(new MediumRunnable()); - ForkJoinTask b = p.submit(new MediumRunnable()); - ForkJoinTask c = p.submit(new MediumRunnable()); + final CountDownLatch done = new CountDownLatch(1); + SubFJP p = new SubFJP(); + try (PoolCleaner cleaner = cleaner(p)) { + ForkJoinTask a = p.submit(awaiter(done)); + ForkJoinTask b = p.submit(awaiter(done)); + ForkJoinTask c = p.submit(awaiter(done)); ForkJoinTask r = p.pollSubmission(); assertTrue(r == a || r == b || r == c); assertFalse(r.isDone()); - } finally { - joinPool(p); + done.countDown(); } } @@ -440,12 +380,12 @@ public class ForkJoinPoolTest extends JS * drainTasksTo transfers unexecuted submitted tasks, if present */ public void testDrainTasksTo() { - SubFJP p = null; - try { - p = new SubFJP(); - ForkJoinTask a = p.submit(new MediumRunnable()); - ForkJoinTask b = p.submit(new MediumRunnable()); - ForkJoinTask c = p.submit(new MediumRunnable()); + final CountDownLatch done = new CountDownLatch(1); + SubFJP p = new SubFJP(); + try (PoolCleaner cleaner = cleaner(p)) { + ForkJoinTask a = p.submit(awaiter(done)); + ForkJoinTask b = p.submit(awaiter(done)); + ForkJoinTask c = p.submit(awaiter(done)); ArrayList al = new ArrayList(); p.drainTasksTo(al); assertTrue(al.size() > 0); @@ -453,12 +393,10 @@ public class ForkJoinPoolTest extends JS assertTrue(r == a || r == b || r == c); assertFalse(r.isDone()); } - } finally { - joinPool(p); + done.countDown(); } } - // FJ Versions of AbstractExecutorService tests /** @@ -466,22 +404,31 @@ public class ForkJoinPoolTest extends JS */ public void testExecuteRunnable() throws Throwable { ExecutorService e = new ForkJoinPool(1); - TrackedShortRunnable task = new TrackedShortRunnable(); - assertFalse(task.done); - Future future = e.submit(task); - future.get(); - assertTrue(task.done); + try (PoolCleaner cleaner = cleaner(e)) { + 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() throws Throwable { ExecutorService e = new ForkJoinPool(1); - Future future = e.submit(new StringTask()); - String result = future.get(); - assertSame(TEST_STRING, result); + try (PoolCleaner cleaner = cleaner(e)) { + Future future = e.submit(new StringTask()); + assertSame(TEST_STRING, future.get()); + assertTrue(future.isDone()); + assertFalse(future.isCancelled()); + } } /** @@ -489,9 +436,12 @@ public class ForkJoinPoolTest extends JS */ public void testSubmitRunnable() throws Throwable { ExecutorService e = new ForkJoinPool(1); - Future future = e.submit(new NoOpRunnable()); - future.get(); - assertTrue(future.isDone()); + try (PoolCleaner cleaner = cleaner(e)) { + Future future = e.submit(new NoOpRunnable()); + assertNull(future.get()); + assertTrue(future.isDone()); + assertFalse(future.isCancelled()); + } } /** @@ -499,26 +449,28 @@ public class ForkJoinPoolTest extends JS */ public void testSubmitRunnable2() throws Throwable { ExecutorService e = new ForkJoinPool(1); - Future future = e.submit(new NoOpRunnable(), TEST_STRING); - String result = future.get(); - assertSame(TEST_STRING, result); + try (PoolCleaner cleaner = cleaner(e)) { + Future future = e.submit(new NoOpRunnable(), TEST_STRING); + assertSame(TEST_STRING, future.get()); + assertTrue(future.isDone()); + assertFalse(future.isCancelled()); + } } /** * A submitted privileged action runs to completion */ - public void testSubmitPrivilegedAction() throws Throwable { + 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; - }})); - - Object result = future.get(); - assertSame(TEST_STRING, result); - }}; + public void realRun() throws Exception { + ExecutorService e = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(e)) { + Future future = e.submit(callable); + assertSame(TEST_STRING, future.get()); + } + }}; runWithPermissions(r, new RuntimePermission("modifyThread")); } @@ -526,18 +478,18 @@ public class ForkJoinPoolTest extends JS /** * A submitted privileged exception action runs to completion */ - public void testSubmitPrivilegedExceptionAction() throws Throwable { + 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; - }})); - - Object result = future.get(); - assertSame(TEST_STRING, result); - }}; + public void realRun() throws Exception { + ExecutorService e = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(e)) { + Future future = e.submit(callable); + assertSame(TEST_STRING, future.get()); + } + }}; runWithPermissions(r, new RuntimePermission("modifyThread")); } @@ -545,21 +497,23 @@ public class ForkJoinPoolTest extends JS /** * A submitted failed privileged exception action reports exception */ - public void testSubmitFailedPrivilegedExceptionAction() throws Throwable { + 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 (PoolCleaner cleaner = cleaner(e)) { + Future future = e.submit(callable); try { - Object result = future.get(); + future.get(); shouldThrow(); } catch (ExecutionException success) { assertTrue(success.getCause() instanceof IndexOutOfBoundsException); - }}}; + } + } + }}; runWithPermissions(r, new RuntimePermission("modifyThread")); } @@ -568,53 +522,52 @@ public class ForkJoinPoolTest extends JS * execute(null runnable) throws NullPointerException */ public void testExecuteNullRunnable() { - try { - ExecutorService e = new ForkJoinPool(1); - TrackedShortRunnable task = null; - Future future = e.submit(task); - shouldThrow(); - } catch (NullPointerException success) {} + ExecutorService e = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(e)) { + try { + Future future = e.submit((Runnable) null); + shouldThrow(); + } catch (NullPointerException success) {} + } } - /** * submit(null callable) throws NullPointerException */ public void testSubmitNullCallable() { - try { - ExecutorService e = new ForkJoinPool(1); - StringTask t = null; - Future future = e.submit(t); - shouldThrow(); - } catch (NullPointerException success) {} + ExecutorService e = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(e)) { + try { + Future future = e.submit((Callable) null); + shouldThrow(); + } catch (NullPointerException success) {} + } } - /** - * Blocking on submit(callable) throws InterruptedException if - * caller interrupted. + * submit(callable).get() throws InterruptedException if interrupted */ public void testInterruptedSubmit() throws InterruptedException { - final ForkJoinPool p = new ForkJoinPool(1); - - Thread t = new Thread(new CheckedInterruptedRunnable() { - public void realRun() throws Throwable { - p.submit(new CheckedCallable() { - public Object realCall() throws Throwable { - try { - Thread.sleep(MEDIUM_DELAY_MS); - } catch (InterruptedException ok) { - } - return null; - }}).get(); - }}); - - t.start(); - Thread.sleep(SHORT_DELAY_MS); - t.interrupt(); - t.join(); - p.shutdownNow(); - joinPool(p); + final CountDownLatch submitted = new CountDownLatch(1); + final CountDownLatch quittingTime = new CountDownLatch(1); + final Callable awaiter = new CheckedCallable() { + public Void realCall() throws InterruptedException { + assertTrue(quittingTime.await(2*LONG_DELAY_MS, MILLISECONDS)); + return null; + }}; + final ExecutorService p = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(p, quittingTime)) { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + Future future = p.submit(awaiter); + submitted.countDown(); + future.get(); + }}); + t.start(); + await(submitted); + t.interrupt(); + awaitTermination(t); + } } /** @@ -623,18 +576,16 @@ public class ForkJoinPoolTest extends JS */ public void testSubmitEE() throws Throwable { ForkJoinPool p = new ForkJoinPool(1); - try { - p.submit(new Callable() { - public Object call() { - int i = 5/0; - return Boolean.TRUE; - }}).get(); - shouldThrow(); - } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof ArithmeticException); + try (PoolCleaner cleaner = cleaner(p)) { + try { + p.submit(new Callable() { + public Object call() { throw new ArithmeticException(); }}) + .get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof ArithmeticException); + } } - - joinPool(p); } /** @@ -642,12 +593,11 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAny1() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { - e.invokeAny(null); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + try { + e.invokeAny(null); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -656,12 +606,11 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAny2() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { - e.invokeAny(new ArrayList>()); - shouldThrow(); - } catch (IllegalArgumentException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + try { + e.invokeAny(new ArrayList>()); + shouldThrow(); + } catch (IllegalArgumentException success) {} } } @@ -670,14 +619,13 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAny3() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(null); - try { - e.invokeAny(l); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(null); + try { + e.invokeAny(l); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -687,16 +635,15 @@ public class ForkJoinPoolTest extends JS public void testInvokeAny4() throws Throwable { CountDownLatch latch = new CountDownLatch(1); ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(latchAwaitingStringTask(latch)); - l.add(null); - try { - e.invokeAny(l); - shouldThrow(); - } catch (NullPointerException success) { - } finally { + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); + try { + e.invokeAny(l); + shouldThrow(); + } catch (NullPointerException success) {} latch.countDown(); - joinPool(e); } } @@ -705,15 +652,15 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAny5() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new NPETask()); - try { - e.invokeAny(l); - shouldThrow(); - } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof NullPointerException); - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new NPETask()); + try { + e.invokeAny(l); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } } } @@ -722,14 +669,12 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAny6() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { + try (PoolCleaner cleaner = cleaner(e)) { List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); String result = e.invokeAny(l); assertSame(TEST_STRING, result); - } finally { - joinPool(e); } } @@ -738,12 +683,11 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAll1() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { - e.invokeAll(null); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + try { + e.invokeAll(null); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -752,12 +696,10 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAll2() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); - try { + try (PoolCleaner cleaner = cleaner(e)) { List> r = e.invokeAll(new ArrayList>()); assertTrue(r.isEmpty()); - } finally { - joinPool(e); } } @@ -766,15 +708,14 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAll3() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new StringTask()); - l.add(null); - try { - e.invokeAll(l); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new StringTask()); + l.add(null); + try { + e.invokeAll(l); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -784,17 +725,17 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAll4() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new NPETask()); - List> futures = e.invokeAll(l); - assertEquals(1, futures.size()); - try { - futures.get(0).get(); - shouldThrow(); - } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof NullPointerException); - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new NPETask()); + List> futures = e.invokeAll(l); + assertEquals(1, futures.size()); + try { + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } } } @@ -803,7 +744,7 @@ public class ForkJoinPoolTest extends JS */ public void testInvokeAll5() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { + try (PoolCleaner cleaner = cleaner(e)) { List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); @@ -811,23 +752,19 @@ public class ForkJoinPoolTest extends JS assertEquals(2, futures.size()); for (Future future : futures) assertSame(TEST_STRING, future.get()); - } finally { - joinPool(e); } } - /** * timed invokeAny(null) throws NullPointerException */ public void testTimedInvokeAny1() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { - e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + try { + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -836,14 +773,13 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAnyNullTimeUnit() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new StringTask()); - try { - e.invokeAny(l, MEDIUM_DELAY_MS, null); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new StringTask()); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -852,13 +788,12 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAny2() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { - e.invokeAny(new ArrayList>(), - MEDIUM_DELAY_MS, MILLISECONDS); - shouldThrow(); - } catch (IllegalArgumentException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + try { + e.invokeAny(new ArrayList>(), + MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (IllegalArgumentException success) {} } } @@ -868,16 +803,15 @@ public class ForkJoinPoolTest extends JS public void testTimedInvokeAny3() throws Throwable { CountDownLatch latch = new CountDownLatch(1); ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(latchAwaitingStringTask(latch)); - l.add(null); - try { - e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); - shouldThrow(); - } catch (NullPointerException success) { - } finally { + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(latchAwaitingStringTask(latch)); + l.add(null); + try { + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) {} latch.countDown(); - joinPool(e); } } @@ -886,15 +820,17 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAny4() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new NPETask()); - try { - e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); - shouldThrow(); - } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof NullPointerException); - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + long startTime = System.nanoTime(); + List> l = new ArrayList>(); + l.add(new NPETask()); + try { + e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); + } + assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); } } @@ -903,14 +839,14 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAny5() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { + try (PoolCleaner cleaner = cleaner(e)) { + long startTime = System.nanoTime(); List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); - String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS); assertSame(TEST_STRING, result); - } finally { - joinPool(e); + assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS); } } @@ -919,12 +855,11 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAll1() throws Throwable { ExecutorService e = new ForkJoinPool(1); - try { - e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + try { + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -933,14 +868,13 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAllNullTimeUnit() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new StringTask()); - try { - e.invokeAll(l, MEDIUM_DELAY_MS, null); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new StringTask()); + try { + e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -949,13 +883,11 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAll2() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); - try { + try (PoolCleaner cleaner = cleaner(e)) { List> r = e.invokeAll(new ArrayList>(), MEDIUM_DELAY_MS, MILLISECONDS); assertTrue(r.isEmpty()); - } finally { - joinPool(e); } } @@ -964,15 +896,14 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAll3() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new StringTask()); - l.add(null); - try { - e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); - shouldThrow(); - } catch (NullPointerException success) { - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new StringTask()); + l.add(null); + try { + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (NullPointerException success) {} } } @@ -981,18 +912,18 @@ public class ForkJoinPoolTest extends JS */ public void testTimedInvokeAll4() throws Throwable { ExecutorService e = new ForkJoinPool(1); - List> l = new ArrayList>(); - l.add(new NPETask()); - List> futures - = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); - assertEquals(1, futures.size()); - try { - futures.get(0).get(); - shouldThrow(); - } catch (ExecutionException success) { - assertTrue(success.getCause() instanceof NullPointerException); - } finally { - joinPool(e); + try (PoolCleaner cleaner = cleaner(e)) { + List> l = new ArrayList>(); + l.add(new NPETask()); + List> 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); + } } } @@ -1000,18 +931,16 @@ public class ForkJoinPoolTest extends JS * timed invokeAll(c) returns results of all completed tasks in c */ public void testTimedInvokeAll5() throws Throwable { - ExecutorService e = new ForkJoinPool(1); - try { + ForkJoinPool e = new ForkJoinPool(1); + try (PoolCleaner cleaner = cleaner(e)) { List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); List> futures - = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + = e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS); assertEquals(2, futures.size()); for (Future future : futures) assertSame(TEST_STRING, future.get()); - } finally { - joinPool(e); } }