--- jsr166/src/test/tck/ForkJoinPoolTest.java 2009/07/31 23:02:49 1.1 +++ jsr166/src/test/tck/ForkJoinPoolTest.java 2010/09/17 01:04:10 1.27 @@ -4,17 +4,36 @@ * http://creativecommons.org/licenses/publicdomain */ - import junit.framework.*; -import java.util.*; -import java.util.concurrent.*; -import java.util.concurrent.locks.*; -import java.security.*; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.Executors; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.AbstractExecutorService; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Callable; +import java.util.concurrent.Future; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.CancellationException; +import java.util.concurrent.RejectedExecutionException; +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.ForkJoinTask; +import java.util.concurrent.ForkJoinWorkerThread; +import java.util.concurrent.RecursiveTask; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.ReentrantLock; +import static java.util.concurrent.TimeUnit.MILLISECONDS; +import java.security.AccessControlException; +import java.security.Policy; +import java.security.PrivilegedAction; +import java.security.PrivilegedExceptionAction; -public class ForkJoinPoolTest extends JSR166TestCase{ +public class ForkJoinPoolTest extends JSR166TestCase { public static void main(String[] args) { - junit.textui.TestRunner.run (suite()); + junit.textui.TestRunner.run(suite()); } + public static Test suite() { return new TestSuite(ForkJoinPoolTest.class); } @@ -25,12 +44,12 @@ public class ForkJoinPoolTest extends JS * 1. shutdown and related methods are tested via super.joinPool. * * 2. newTaskFor and adapters are tested in submit/invoke tests - * + * * 3. We cannot portably test monitoring methods such as * getStealCount() since they rely ultimately on random task * stealing that may cause tasks not to be stolen/propagated * across threads, especially on uniprocessors. - * + * * 4. There are no independently testable ForkJoinWorkerThread * methods, but they are covered here and in task tests. */ @@ -38,7 +57,7 @@ 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; } @@ -47,18 +66,19 @@ public class ForkJoinPoolTest extends JS // 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 Error(); } } - static class FailingThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFactory { - int calls = 0; - public ForkJoinWorkerThread newThread(ForkJoinPool p){ + static class FailingThreadFactory + implements ForkJoinPool.ForkJoinWorkerThreadFactory { + volatile int calls = 0; + public ForkJoinWorkerThread newThread(ForkJoinPool p) { if (++calls > 1) return null; return new FailingFJWSubclass(p); - } + } } - static class SubFJP extends ForkJoinPool { // to expose protected + static class SubFJP extends ForkJoinPool { // to expose protected SubFJP() { super(1); } public int drainTasksTo(Collection> c) { return super.drainTasksTo(c); @@ -83,7 +103,7 @@ public class ForkJoinPoolTest extends JS } // A simple recursive task for testing - static final class FibTask extends RecursiveTask { + static final class FibTask extends RecursiveTask { final int number; FibTask(int n) { number = n; } public Integer compute() { @@ -97,7 +117,7 @@ public class ForkJoinPoolTest extends JS } // A failing task for testing - static final class FailingTask extends ForkJoinTask { + static final class FailingTask extends ForkJoinTask { public final Void getRawResult() { return null; } protected final void setRawResult(Void mustBeNull) { } protected final boolean exec() { throw new Error(); } @@ -105,12 +125,12 @@ public class ForkJoinPoolTest extends JS } // Fib needlessly using locking to test ManagedBlockers - static final class LockingFibTask extends RecursiveTask { + static final class LockingFibTask extends RecursiveTask { final int number; final ManagedLocker locker; final ReentrantLock lock; - LockingFibTask(int n, ManagedLocker locker, ReentrantLock lock) { - number = n; + LockingFibTask(int n, ManagedLocker locker, ReentrantLock lock) { + number = n; this.locker = locker; this.lock = lock; } @@ -119,7 +139,7 @@ public class ForkJoinPoolTest extends JS LockingFibTask f1 = null; LockingFibTask f2 = null; locker.block(); - n = number; + n = number; if (n > 1) { f1 = new LockingFibTask(n - 1, locker, lock); f2 = new LockingFibTask(n - 2, locker, lock); @@ -134,23 +154,22 @@ public class ForkJoinPoolTest extends JS } } - /** - * Succesfully constructed pool reports default factory, + /** + * Successfully constructed pool reports default factory, * parallelism and async mode policies, no active threads or * tasks, and quiescent running state. */ public void testDefaultInitialState() { - ForkJoinPool p = null; + ForkJoinPool p = new ForkJoinPool(1); try { - p = new ForkJoinPool(1); - assertTrue(p.getFactory() == ForkJoinPool.defaultForkJoinWorkerThreadFactory); + assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, + p.getFactory()); assertTrue(p.isQuiescent()); - assertTrue(p.getMaintainsParallelism()); 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()); @@ -160,210 +179,99 @@ public class ForkJoinPoolTest extends JS } } - /** - * Constructor throws if size argument is less than zero + /** + * Constructor throws if size argument is less than zero */ public void testConstructor1() { try { new ForkJoinPool(-1); shouldThrow(); - } - catch (IllegalArgumentException success){} + } catch (IllegalArgumentException success) {} } - /** - * Constructor throws if factory argument is null + /** + * Constructor throws if factory argument is null */ public void testConstructor2() { try { - new ForkJoinPool(1, null); + new ForkJoinPool(1, null, null, false); shouldThrow(); - } - catch (NullPointerException success){} + } catch (NullPointerException success) {} } - /** - * getParallelism returns size set in constructor + /** + * 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; + ForkJoinPool p = new ForkJoinPool(1); try { - p = new ForkJoinPool(1); - assertTrue(p.getParallelism() == 1); - p.setParallelism(-2); - shouldThrow(); - }catch (IllegalArgumentException success){ + assertEquals(1, p.getParallelism()); } finally { joinPool(p); } } - /** + /** * getPoolSize returns number of started workers. */ public void testGetPoolSize() { - ForkJoinPool p = null; + ForkJoinPool p = new ForkJoinPool(1); try { - p = new ForkJoinPool(1); - assertTrue(p.getPoolSize() == 0); + 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){ + assertEquals(1, p.getPoolSize()); } 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); - } - } - - /** - * setAsyncMode changes policy reported by - * getAsyncMode. - */ - public void testSetAsyncMode() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setAsyncMode(true); - assertTrue(p.getAsyncMode()); - } finally { - joinPool(p); - } - } - - /** + /** * setUncaughtExceptionHandler changes handler for uncaught exceptions. * * Additionally tests: Overriding ForkJoinWorkerThread.onStart * performs its defined action */ - public void testSetUncaughtExceptionHandler() { - ForkJoinPool p = null; + public void testSetUncaughtExceptionHandler() throws InterruptedException { + final CountDownLatch uncaughtExceptionHappened = new CountDownLatch(1); + final Thread.UncaughtExceptionHandler eh = + new Thread.UncaughtExceptionHandler() { + public void uncaughtException(Thread t, Throwable e) { + uncaughtExceptionHappened.countDown(); + }}; + ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(), + eh, false); try { - p = new ForkJoinPool(1, new FailingThreadFactory()); - MyHandler eh = new MyHandler(); - p.setUncaughtExceptionHandler(eh); - assertEquals(eh, p.getUncaughtExceptionHandler()); + assertSame(eh, p.getUncaughtExceptionHandler()); p.execute(new FailingTask()); - Thread.sleep(MEDIUM_DELAY_MS); - assertTrue(eh.catches > 0); - } catch(InterruptedException e){ - unexpectedException(); - } finally { - joinPool(p); - } - } - - /** - * setUncaughtExceptionHandler of null removes handler - */ - public void testSetUncaughtExceptionHandler2() { - ForkJoinPool p = null; - try { - p = new ForkJoinPool(1); - p.setUncaughtExceptionHandler(null); - assertNull(p.getUncaughtExceptionHandler()); + uncaughtExceptionHappened.await(); } finally { + //p.shutdownNow(); joinPool(p); } } - - /** + /** * After invoking a single task, isQuiescent is true, * queues are empty, threads are not active, and * construction parameters continue to hold */ - public void testisQuiescent() { - ForkJoinPool p = null; + public void testisQuiescent() throws InterruptedException { + ForkJoinPool p = new ForkJoinPool(2); try { - p = new ForkJoinPool(2); p.invoke(new FibTask(20)); - assertTrue(p.getFactory() == ForkJoinPool.defaultForkJoinWorkerThreadFactory); + assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory, + p.getFactory()); 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()); - } catch(InterruptedException e){ - unexpectedException(); } finally { joinPool(p); } @@ -372,17 +280,11 @@ public class ForkJoinPoolTest extends JS /** * Completed submit(ForkJoinTask) returns result */ - public void testSubmitForkJoinTask() { - ForkJoinPool p = null; + public void testSubmitForkJoinTask() throws Throwable { + ForkJoinPool p = new ForkJoinPool(1); try { - p = new ForkJoinPool(1); ForkJoinTask f = p.submit(new FibTask(8)); - int r = f.get(); - assertTrue(r == 21); - } catch (ExecutionException ex) { - unexpectedException(); - } catch (InterruptedException ex) { - unexpectedException(); + assertEquals(21, (int) f.get()); } finally { joinPool(p); } @@ -392,14 +294,14 @@ public class ForkJoinPoolTest extends JS * A task submitted after shutdown is rejected */ public void testSubmitAfterShutdown() { - ForkJoinPool p = null; + ForkJoinPool p = new ForkJoinPool(1); try { - p = new ForkJoinPool(1); p.shutdown(); assertTrue(p.isShutdown()); - ForkJoinTask f = p.submit(new FibTask(8)); - shouldThrow(); - } catch (RejectedExecutionException success) { + try { + ForkJoinTask f = p.submit(new FibTask(8)); + shouldThrow(); + } catch (RejectedExecutionException success) {} } finally { joinPool(p); } @@ -408,23 +310,16 @@ public class ForkJoinPoolTest extends JS /** * Pool maintains parallelism when using ManagedBlocker */ - public void testBlockingForkJoinTask() { - ForkJoinPool p = null; + public void testBlockingForkJoinTask() throws Throwable { + 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); p.execute(f); - assertTrue(p.getPoolSize() >= 4); - int r = f.get(); - assertTrue(r == 832040); - } catch (ExecutionException ex) { - unexpectedException(); - } catch (InterruptedException ex) { - unexpectedException(); + assertEquals(832040, (int) f.get()); } finally { - joinPool(p); + p.shutdownNow(); // don't wait out shutdown } } @@ -432,9 +327,8 @@ public class ForkJoinPoolTest extends JS * pollSubmission returns unexecuted submitted task, if present */ public void testPollSubmission() { - SubFJP p = null; + SubFJP p = new SubFJP(); try { - p = new SubFJP(); ForkJoinTask a = p.submit(new MediumRunnable()); ForkJoinTask b = p.submit(new MediumRunnable()); ForkJoinTask c = p.submit(new MediumRunnable()); @@ -450,9 +344,8 @@ public class ForkJoinPoolTest extends JS * drainTasksTo transfers unexecuted submitted tasks, if present */ public void testDrainTasksTo() { - SubFJP p = null; + SubFJP p = new SubFJP(); try { - p = new SubFJP(); ForkJoinTask a = p.submit(new MediumRunnable()); ForkJoinTask b = p.submit(new MediumRunnable()); ForkJoinTask c = p.submit(new MediumRunnable()); @@ -468,26 +361,22 @@ public class ForkJoinPoolTest extends JS } } - + // FJ Versions of AbstractExecutorService tests /** * execute(runnable) runs it to completion */ - public void testExecuteRunnable() { + public void testExecuteRunnable() throws Throwable { + ExecutorService e = new ForkJoinPool(1); try { - ExecutorService e = new ForkJoinPool(1); 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(); + } finally { + joinPool(e); } } @@ -495,54 +384,42 @@ public class ForkJoinPoolTest extends JS /** * Completed submit(callable) returns result */ - public void testSubmitCallable() { + public void testSubmitCallable() throws Throwable { + ExecutorService e = new ForkJoinPool(1); try { - ExecutorService e = new ForkJoinPool(1); Future future = e.submit(new StringTask()); String result = future.get(); assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); + } finally { + joinPool(e); } } /** * Completed submit(runnable) returns successfully */ - public void testSubmitRunnable() { + public void testSubmitRunnable() throws Throwable { + ExecutorService e = new ForkJoinPool(1); try { - ExecutorService e = new ForkJoinPool(1); Future future = e.submit(new NoOpRunnable()); future.get(); assertTrue(future.isDone()); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); + } finally { + joinPool(e); } } /** * Completed submit(runnable, result) returns result */ - public void testSubmitRunnable2() { + public void testSubmitRunnable2() throws Throwable { + ExecutorService e = new ForkJoinPool(1); try { - ExecutorService e = new ForkJoinPool(1); Future future = e.submit(new NoOpRunnable(), TEST_STRING); String result = future.get(); assertSame(TEST_STRING, result); - } - catch (ExecutionException ex) { - unexpectedException(); - } - catch (InterruptedException ex) { - unexpectedException(); + } finally { + joinPool(e); } } @@ -550,7 +427,7 @@ public class ForkJoinPoolTest extends JS /** * A submitted privileged action to completion */ - public void testSubmitPrivilegedAction() { + public void testSubmitPrivilegedAction() throws Throwable { Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); @@ -558,38 +435,32 @@ public class ForkJoinPoolTest extends JS policy.addPermission(new RuntimePermission("getContextClassLoader")); policy.addPermission(new RuntimePermission("setContextClassLoader")); Policy.setPolicy(policy); - } catch(AccessControlException ok) { + } catch (AccessControlException ok) { return; } + try { ExecutorService e = new ForkJoinPool(1); - Future future = e.submit(Executors.callable(new PrivilegedAction() { + try { + 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; + Object result = future.get(); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); } + } finally { + Policy.setPolicy(savedPolicy); } } /** * A submitted a privileged exception action runs to completion */ - public void testSubmitPrivilegedExceptionAction() { + public void testSubmitPrivilegedExceptionAction() throws Throwable { Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); @@ -597,27 +468,24 @@ public class ForkJoinPoolTest extends JS policy.addPermission(new RuntimePermission("getContextClassLoader")); policy.addPermission(new RuntimePermission("setContextClassLoader")); Policy.setPolicy(policy); - } catch(AccessControlException ok) { + } catch (AccessControlException ok) { return; } try { ExecutorService e = new ForkJoinPool(1); - Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() { + try { + 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 { + Object result = future.get(); + assertSame(TEST_STRING, result); + } finally { + joinPool(e); + } + } finally { Policy.setPolicy(savedPolicy); } } @@ -625,7 +493,7 @@ public class ForkJoinPoolTest extends JS /** * A submitted failed privileged exception action reports exception */ - public void testSubmitFailedPrivilegedExceptionAction() { + public void testSubmitFailedPrivilegedExceptionAction() throws Throwable { Policy savedPolicy = null; try { savedPolicy = Policy.getPolicy(); @@ -633,177 +501,170 @@ public class ForkJoinPoolTest extends JS policy.addPermission(new RuntimePermission("getContextClassLoader")); policy.addPermission(new RuntimePermission("setContextClassLoader")); Policy.setPolicy(policy); - } catch(AccessControlException ok) { + } catch (AccessControlException ok) { return; } - try { ExecutorService e = new ForkJoinPool(1); - Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() { + try { + 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 (CancellationException success) { - } catch (InterruptedException ex) { - unexpectedException(); - } - finally { + Object result = future.get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof IndexOutOfBoundsException); + } finally { + joinPool(e); + } + } finally { Policy.setPolicy(savedPolicy); } } /** - * execute(null runnable) throws NPE + * execute(null runnable) throws NullPointerException */ public void testExecuteNullRunnable() { + ExecutorService e = new ForkJoinPool(1); + TrackedShortRunnable task = null; try { - ExecutorService e = new ForkJoinPool(1); - TrackedShortRunnable task = null; Future future = e.submit(task); shouldThrow(); - } - catch (NullPointerException success) { - } - catch (Exception ex) { - unexpectedException(); + } catch (NullPointerException success) { + } finally { + joinPool(e); } } /** - * submit(null callable) throws NPE + * submit(null callable) throws NullPointerException */ public void testSubmitNullCallable() { + ExecutorService e = new ForkJoinPool(1); + StringTask t = null; try { - ExecutorService e = new ForkJoinPool(1); - StringTask t = null; Future future = e.submit(t); shouldThrow(); - } - catch (NullPointerException success) { - } - catch (Exception ex) { - unexpectedException(); + } catch (NullPointerException success) { + } finally { + joinPool(e); } } /** - * Blocking on submit(callable) throws InterruptedException if - * caller interrupted. - */ - public void testInterruptedSubmit() { - final ForkJoinPool p = new ForkJoinPool(1); - Thread t = new Thread(new Runnable() { - public void run() { - try { - p.submit(new Callable() { - public Object call() { - try { - Thread.sleep(MEDIUM_DELAY_MS); - shouldThrow(); - } catch(InterruptedException e){ - } - return null; - } - }).get(); - } catch(InterruptedException success){ - } catch(Exception e) { - unexpectedException(); - } - - } - }); - try { + * submit(callable).get() throws InterruptedException if interrupted + */ + public void testInterruptedSubmit() throws InterruptedException { + final CountDownLatch submitted = new CountDownLatch(1); + final CountDownLatch quittingTime = new CountDownLatch(1); + final ExecutorService p = new ForkJoinPool(1); + final Callable awaiter = new CheckedCallable() { + public Void realCall() throws InterruptedException { + assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS)); + return null; + }}; + try { + Thread t = new Thread(new CheckedInterruptedRunnable() { + public void realRun() throws Exception { + Future future = p.submit(awaiter); + submitted.countDown(); + future.get(); + }}); t.start(); - Thread.sleep(SHORT_DELAY_MS); + assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS)); t.interrupt(); - } catch(Exception e){ - unexpectedException(); + t.join(); + } finally { + quittingTime.countDown(); + joinPool(p); } - 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() { + public void testSubmitEE() throws Throwable { ForkJoinPool p = new ForkJoinPool(1); - try { - Callable c = new Callable() { - public Object call() { - int i = 5/0; - return Boolean.TRUE; - } - }; - - for(int i =0; i < 5; i++){ - p.submit(c).get(); - } - + p.submit(new Callable() { + public Object call() { + int i = 5/0; + return Boolean.TRUE; + }}).get(); shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof ArithmeticException); + } finally { + joinPool(p); } - catch(ExecutionException success){ - } catch (CancellationException success) { - } catch(Exception e) { - unexpectedException(); - } - joinPool(p); } /** - * invokeAny(null) throws NPE + * invokeAny(null) throws NullPointerException */ - public void testInvokeAny1() { + public void testInvokeAny1() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { e.invokeAny(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } } /** - * invokeAny(empty collection) throws IAE + * invokeAny(empty collection) throws IllegalArgumentException */ - public void testInvokeAny2() { + public void testInvokeAny2() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { e.invokeAny(new ArrayList>()); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } } /** - * invokeAny(c) throws NPE if c has null elements + * invokeAny(c) throws NullPointerException if c has a single null element */ - public void testInvokeAny3() { + 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); + } + } + + /** + * invokeAny(c) throws NullPointerException if c has null elements + */ + 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 { - ArrayList> l = new ArrayList>(); - l.add(new StringTask()); - l.add(null); e.invokeAny(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { + latch.countDown(); joinPool(e); } } @@ -811,16 +672,15 @@ public class ForkJoinPoolTest extends JS /** * invokeAny(c) throws ExecutionException if no task in c completes */ - public void testInvokeAny4() { + public void testInvokeAny5() throws Throwable { ExecutorService e = new ForkJoinPool(1); + List> l = new ArrayList>(); + l.add(new NPETask()); try { - ArrayList> l = new ArrayList>(); - l.add(new NPETask()); e.invokeAny(l); - } catch(ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - unexpectedException(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -829,33 +689,28 @@ public class ForkJoinPoolTest extends JS /** * invokeAny(c) returns result of some task in c if at least one completes */ - public void testInvokeAny5() { + public void testInvokeAny6() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - ArrayList> l = new ArrayList>(); + List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); String result = e.invokeAny(l); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } } /** - * invokeAll(null) throws NPE + * invokeAll(null) throws NullPointerException */ - public void testInvokeAll1() { + public void testInvokeAll1() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { e.invokeAll(null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } @@ -864,53 +719,49 @@ public class ForkJoinPoolTest extends JS /** * invokeAll(empty collection) returns empty collection */ - public void testInvokeAll2() { + public void testInvokeAll2() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); try { - List> r = e.invokeAll(new ArrayList>()); + List> r + = e.invokeAll(new ArrayList>()); assertTrue(r.isEmpty()); - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } } /** - * invokeAll(c) throws NPE if c has null elements + * invokeAll(c) throws NullPointerException if c has null elements */ - public void testInvokeAll3() { + public void testInvokeAll3() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); + List> l = new ArrayList>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList> l = new ArrayList>(); - l.add(new StringTask()); - l.add(null); e.invokeAll(l); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - unexpectedException(); } finally { joinPool(e); } } /** - * get of returned element of invokeAll(c) throws exception on failed task + * get of returned element of invokeAll(c) throws + * ExecutionException on failed task */ - public void testInvokeAll4() { + 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 { - ArrayList> l = new ArrayList>(); - l.add(new NPETask()); - List> result = e.invokeAll(l); - assertEquals(1, result.size()); - for (Iterator> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -919,21 +770,16 @@ public class ForkJoinPoolTest extends JS /** * invokeAll(c) returns results of all completed tasks in c */ - public void testInvokeAll5() { + public void testInvokeAll5() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - ArrayList> l = new ArrayList>(); + List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); - List> result = e.invokeAll(l); - assertEquals(2, result.size()); - for (Iterator> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); + List> futures = e.invokeAll(l); + assertEquals(2, futures.size()); + for (Future future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); } @@ -941,70 +787,65 @@ public class ForkJoinPoolTest extends JS /** - * timed invokeAny(null) throws NPE + * timed invokeAny(null) throws NullPointerException */ - public void testTimedInvokeAny1() { + public void testTimedInvokeAny1() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } } /** - * timed invokeAny(null time unit) throws NPE + * timed invokeAny(null time unit) throws NullPointerException */ - public void testTimedInvokeAnyNullTimeUnit() { + public void testTimedInvokeAnyNullTimeUnit() throws Throwable { ExecutorService e = new ForkJoinPool(1); + List> l = new ArrayList>(); + l.add(new StringTask()); try { - ArrayList> l = new ArrayList>(); - l.add(new StringTask()); e.invokeAny(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } } /** - * timed invokeAny(empty collection) throws IAE + * timed invokeAny(empty collection) throws IllegalArgumentException */ - public void testTimedInvokeAny2() { + public void testTimedInvokeAny2() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - e.invokeAny(new ArrayList>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(new ArrayList>(), + MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (IllegalArgumentException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } } /** - * timed invokeAny(c) throws NPE if c has null elements + * timed invokeAny(c) throws NullPointerException if c has null elements */ - public void testTimedInvokeAny3() { + 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 { - ArrayList> l = new ArrayList>(); - l.add(new StringTask()); - l.add(null); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { + latch.countDown(); joinPool(e); } } @@ -1012,17 +853,15 @@ public class ForkJoinPoolTest extends JS /** * timed invokeAny(c) throws ExecutionException if no task completes */ - public void testTimedInvokeAny4() { + public void testTimedInvokeAny4() throws Throwable { ExecutorService e = new ForkJoinPool(1); + List> l = new ArrayList>(); + l.add(new NPETask()); try { - ArrayList> l = new ArrayList>(); - l.add(new NPETask()); - e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - } catch(ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); + e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -1031,53 +870,44 @@ public class ForkJoinPoolTest extends JS /** * timed invokeAny(c) returns result of some task in c */ - public void testTimedInvokeAny5() { + public void testTimedInvokeAny5() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - ArrayList> l = new ArrayList>(); + List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); - String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS); assertSame(TEST_STRING, result); - } catch (ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } } /** - * timed invokeAll(null) throws NPE + * timed invokeAll(null) throws NullPointerException */ - public void testTimedInvokeAll1() { + public void testTimedInvokeAll1() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } } /** - * timed invokeAll(null time unit) throws NPE + * timed invokeAll(null time unit) throws NullPointerException */ - public void testTimedInvokeAllNullTimeUnit() { + public void testTimedInvokeAllNullTimeUnit() throws Throwable { ExecutorService e = new ForkJoinPool(1); + List> l = new ArrayList>(); + l.add(new StringTask()); try { - ArrayList> l = new ArrayList>(); - l.add(new StringTask()); e.invokeAll(l, MEDIUM_DELAY_MS, null); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } @@ -1086,33 +916,30 @@ public class ForkJoinPoolTest extends JS /** * timed invokeAll(empty collection) returns empty collection */ - public void testTimedInvokeAll2() { + public void testTimedInvokeAll2() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); try { - List> r = e.invokeAll(new ArrayList>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + List> r + = e.invokeAll(new ArrayList>(), + MEDIUM_DELAY_MS, MILLISECONDS); assertTrue(r.isEmpty()); - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } } /** - * timed invokeAll(c) throws NPE if c has null elements + * timed invokeAll(c) throws NullPointerException if c has null elements */ - public void testTimedInvokeAll3() { + public void testTimedInvokeAll3() throws InterruptedException { ExecutorService e = new ForkJoinPool(1); + List> l = new ArrayList>(); + l.add(new StringTask()); + l.add(null); try { - ArrayList> l = new ArrayList>(); - l.add(new StringTask()); - l.add(null); - e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); + e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + shouldThrow(); } catch (NullPointerException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); } finally { joinPool(e); } @@ -1121,20 +948,18 @@ public class ForkJoinPoolTest extends JS /** * get of returned element of invokeAll(c) throws exception on failed task */ - public void testTimedInvokeAll4() { + 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 { - ArrayList> l = new ArrayList>(); - l.add(new NPETask()); - List> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(1, result.size()); - for (Iterator> it = result.iterator(); it.hasNext();) - it.next().get(); - } catch(ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); + futures.get(0).get(); + shouldThrow(); + } catch (ExecutionException success) { + assertTrue(success.getCause() instanceof NullPointerException); } finally { joinPool(e); } @@ -1143,21 +968,17 @@ public class ForkJoinPoolTest extends JS /** * timed invokeAll(c) returns results of all completed tasks in c */ - public void testTimedInvokeAll5() { + public void testTimedInvokeAll5() throws Throwable { ExecutorService e = new ForkJoinPool(1); try { - ArrayList> l = new ArrayList>(); + List> l = new ArrayList>(); l.add(new StringTask()); l.add(new StringTask()); - List> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); - assertEquals(2, result.size()); - for (Iterator> it = result.iterator(); it.hasNext();) - assertSame(TEST_STRING, it.next().get()); - } catch (ExecutionException success) { - } catch (CancellationException success) { - } catch(Exception ex) { - ex.printStackTrace(); - unexpectedException(); + List> futures + = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS); + assertEquals(2, futures.size()); + for (Future future : futures) + assertSame(TEST_STRING, future.get()); } finally { joinPool(e); }