ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ForkJoinPoolTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ForkJoinPoolTest.java (file contents):
Revision 1.8 by jsr166, Tue Aug 4 21:10:19 2009 UTC vs.
Revision 1.43 by jsr166, Sun May 29 13:45:35 2011 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7
7   import junit.framework.*;
8 < import java.util.*;
9 < import java.util.concurrent.*;
8 > import java.util.ArrayList;
9 > import java.util.Collection;
10 > import java.util.List;
11 > import java.util.concurrent.Executors;
12 > import java.util.concurrent.ExecutorService;
13 > import java.util.concurrent.AbstractExecutorService;
14 > import java.util.concurrent.CountDownLatch;
15 > import java.util.concurrent.Callable;
16 > import java.util.concurrent.Future;
17 > import java.util.concurrent.ExecutionException;
18 > import java.util.concurrent.CancellationException;
19 > import java.util.concurrent.RejectedExecutionException;
20 > import java.util.concurrent.ForkJoinPool;
21 > import java.util.concurrent.ForkJoinTask;
22 > import java.util.concurrent.ForkJoinWorkerThread;
23 > import java.util.concurrent.RecursiveTask;
24 > import java.util.concurrent.TimeUnit;
25 > import java.util.concurrent.atomic.AtomicBoolean;
26 > import java.util.concurrent.locks.ReentrantLock;
27   import static java.util.concurrent.TimeUnit.MILLISECONDS;
28 < import java.util.concurrent.locks.*;
29 < import java.security.*;
28 > import java.security.AccessControlException;
29 > import java.security.Policy;
30 > import java.security.PrivilegedAction;
31 > import java.security.PrivilegedExceptionAction;
32  
33   public class ForkJoinPoolTest extends JSR166TestCase {
34      public static void main(String[] args) {
35 <        junit.textui.TestRunner.run (suite());
35 >        junit.textui.TestRunner.run(suite());
36      }
37 +
38      public static Test suite() {
39          return new TestSuite(ForkJoinPoolTest.class);
40      }
# Line 39 | Line 58 | public class ForkJoinPoolTest extends JS
58      // Some classes to test extension and factory methods
59  
60      static class MyHandler implements Thread.UncaughtExceptionHandler {
61 <        int catches = 0;
61 >        volatile int catches = 0;
62          public void uncaughtException(Thread t, Throwable e) {
63              ++catches;
64          }
# Line 48 | Line 67 | public class ForkJoinPoolTest extends JS
67      // to test handlers
68      static class FailingFJWSubclass extends ForkJoinWorkerThread {
69          public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
70 <        protected void onStart() { throw new Error(); }
70 >        protected void onStart() { super.onStart(); throw new Error(); }
71      }
72  
73      static class FailingThreadFactory
74              implements ForkJoinPool.ForkJoinWorkerThreadFactory {
75 <        int calls = 0;
75 >        volatile int calls = 0;
76          public ForkJoinWorkerThread newThread(ForkJoinPool p) {
77              if (++calls > 1) return null;
78              return new FailingFJWSubclass(p);
# Line 142 | Line 161 | public class ForkJoinPoolTest extends JS
161       * tasks, and quiescent running state.
162       */
163      public void testDefaultInitialState() {
164 <        ForkJoinPool p = null;
164 >        ForkJoinPool p = new ForkJoinPool(1);
165          try {
166 <            p = new ForkJoinPool(1);
167 <            assertTrue(p.getFactory() ==
149 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
150 <            assertTrue(p.isQuiescent());
151 <            assertTrue(p.getMaintainsParallelism());
166 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
167 >                       p.getFactory());
168              assertFalse(p.getAsyncMode());
169 <            assertTrue(p.getActiveThreadCount() == 0);
170 <            assertTrue(p.getStealCount() == 0);
171 <            assertTrue(p.getQueuedTaskCount() == 0);
172 <            assertTrue(p.getQueuedSubmissionCount() == 0);
169 >            assertEquals(0, p.getActiveThreadCount());
170 >            assertEquals(0, p.getStealCount());
171 >            assertEquals(0, p.getQueuedTaskCount());
172 >            assertEquals(0, p.getQueuedSubmissionCount());
173              assertFalse(p.hasQueuedSubmissions());
174              assertFalse(p.isShutdown());
175              assertFalse(p.isTerminating());
# Line 170 | Line 186 | public class ForkJoinPoolTest extends JS
186          try {
187              new ForkJoinPool(-1);
188              shouldThrow();
189 <        }
174 <        catch (IllegalArgumentException success) {}
189 >        } catch (IllegalArgumentException success) {}
190      }
191  
192      /**
# Line 179 | Line 194 | public class ForkJoinPoolTest extends JS
194       */
195      public void testConstructor2() {
196          try {
197 <            new ForkJoinPool(1, null);
197 >            new ForkJoinPool(1, null, null, false);
198              shouldThrow();
199 <        } catch (NullPointerException success) {
185 <        }
199 >        } catch (NullPointerException success) {}
200      }
201  
188
202      /**
203       * getParallelism returns size set in constructor
204       */
205      public void testGetParallelism() {
206 <        ForkJoinPool p = null;
194 <        try {
195 <            p = new ForkJoinPool(1);
196 <            assertTrue(p.getParallelism() == 1);
197 <        } finally {
198 <            joinPool(p);
199 <        }
200 <    }
201 <
202 <    /**
203 <     * setParallelism changes reported parallelism level.
204 <     */
205 <    public void testSetParallelism() {
206 <        ForkJoinPool p = null;
207 <        try {
208 <            p = new ForkJoinPool(1);
209 <            assertTrue(p.getParallelism() == 1);
210 <            p.setParallelism(2);
211 <            assertTrue(p.getParallelism() == 2);
212 <        } finally {
213 <            joinPool(p);
214 <        }
215 <    }
216 <
217 <    /**
218 <     * setParallelism with argument <= 0 throws exception
219 <     */
220 <    public void testSetParallelism2() {
221 <        ForkJoinPool p = null;
206 >        ForkJoinPool p = new ForkJoinPool(1);
207          try {
208 <            p = new ForkJoinPool(1);
224 <            assertTrue(p.getParallelism() == 1);
225 <            p.setParallelism(-2);
226 <            shouldThrow();
227 <        } catch (IllegalArgumentException success) {
208 >            assertEquals(1, p.getParallelism());
209          } finally {
210              joinPool(p);
211          }
# Line 234 | Line 215 | public class ForkJoinPoolTest extends JS
215       * getPoolSize returns number of started workers.
216       */
217      public void testGetPoolSize() {
218 <        ForkJoinPool p = null;
218 >        ForkJoinPool p = new ForkJoinPool(1);
219          try {
220 <            p = new ForkJoinPool(1);
240 <            assertTrue(p.getPoolSize() == 0);
220 >            assertEquals(0, p.getActiveThreadCount());
221              Future<String> future = p.submit(new StringTask());
222 <            assertTrue(p.getPoolSize() == 1);
243 <
244 <        } finally {
245 <            joinPool(p);
246 <        }
247 <    }
248 <
249 <    /**
250 <     * setMaximumPoolSize changes size reported by getMaximumPoolSize.
251 <     */
252 <    public void testSetMaximumPoolSize() {
253 <        ForkJoinPool p = null;
254 <        try {
255 <            p = new ForkJoinPool(1);
256 <            p.setMaximumPoolSize(2);
257 <            assertTrue(p.getMaximumPoolSize() == 2);
258 <        } finally {
259 <            joinPool(p);
260 <        }
261 <    }
262 <
263 <    /**
264 <     * setMaximumPoolSize with argument <= 0 throws exception
265 <     */
266 <    public void testSetMaximumPoolSize2() {
267 <        ForkJoinPool p = null;
268 <        try {
269 <            p = new ForkJoinPool(1);
270 <            p.setMaximumPoolSize(-2);
271 <            shouldThrow();
272 <        } catch (IllegalArgumentException success) {
273 <        } finally {
274 <            joinPool(p);
275 <        }
276 <    }
277 <
278 <    /**
279 <     * setMaintainsParallelism changes policy reported by
280 <     * getMaintainsParallelism.
281 <     */
282 <    public void testSetMaintainsParallelism() {
283 <        ForkJoinPool p = null;
284 <        try {
285 <            p = new ForkJoinPool(1);
286 <            p.setMaintainsParallelism(false);
287 <            assertFalse(p.getMaintainsParallelism());
288 <        } finally {
289 <            joinPool(p);
290 <        }
291 <    }
292 <
293 <    /**
294 <     * setAsyncMode changes policy reported by
295 <     * getAsyncMode.
296 <     */
297 <    public void testSetAsyncMode() {
298 <        ForkJoinPool p = null;
299 <        try {
300 <            p = new ForkJoinPool(1);
301 <            p.setAsyncMode(true);
302 <            assertTrue(p.getAsyncMode());
222 >            assertEquals(1, p.getPoolSize());
223          } finally {
224              joinPool(p);
225          }
# Line 312 | Line 232 | public class ForkJoinPoolTest extends JS
232       * performs its defined action
233       */
234      public void testSetUncaughtExceptionHandler() throws InterruptedException {
235 <        ForkJoinPool p = null;
235 >        final CountDownLatch uehInvoked = new CountDownLatch(1);
236 >        final Thread.UncaughtExceptionHandler eh =
237 >            new Thread.UncaughtExceptionHandler() {
238 >                public void uncaughtException(Thread t, Throwable e) {
239 >                    uehInvoked.countDown();
240 >                }};
241 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
242 >                                          eh, false);
243          try {
244 <            p = new ForkJoinPool(1, new FailingThreadFactory());
245 <            MyHandler eh = new MyHandler();
246 <            p.setUncaughtExceptionHandler(eh);
320 <            assertEquals(eh, p.getUncaughtExceptionHandler());
321 <            p.execute(new FailingTask());
322 <            Thread.sleep(MEDIUM_DELAY_MS);
323 <            assertTrue(eh.catches > 0);
244 >            assertSame(eh, p.getUncaughtExceptionHandler());
245 >            p.execute(new FibTask(8));
246 >            assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
247          } finally {
248 +            p.shutdownNow(); // failure might have prevented processing task
249              joinPool(p);
250          }
251      }
252  
253      /**
254 <     * setUncaughtExceptionHandler of null removes handler
254 >     * After invoking a single task, isQuiescent eventually becomes
255 >     * true, at which time queues are empty, threads are not active,
256 >     * the task has completed successfully, and construction
257 >     * parameters continue to hold
258       */
259 <    public void testSetUncaughtExceptionHandler2() {
260 <        ForkJoinPool p = null;
259 >    public void testIsQuiescent() throws Exception {
260 >        ForkJoinPool p = new ForkJoinPool(2);
261          try {
262 <            p = new ForkJoinPool(1);
263 <            p.setUncaughtExceptionHandler(null);
264 <            assertNull(p.getUncaughtExceptionHandler());
265 <        } finally {
266 <            joinPool(p);
267 <        }
268 <    }
269 <
262 >            assertTrue(p.isQuiescent());
263 >            long startTime = System.nanoTime();
264 >            FibTask f = new FibTask(20);
265 >            p.invoke(f);
266 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
267 >                       p.getFactory());
268 >            while (! p.isQuiescent()) {
269 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
270 >                    throw new AssertionFailedError("timed out");
271 >                assertFalse(p.getAsyncMode());
272 >                assertFalse(p.isShutdown());
273 >                assertFalse(p.isTerminating());
274 >                assertFalse(p.isTerminated());
275 >                Thread.yield();
276 >            }
277  
344    /**
345     * After invoking a single task, isQuiescent is true,
346     * queues are empty, threads are not active, and
347     * construction parameters continue to hold
348     */
349    public void testisQuiescent() throws InterruptedException {
350        ForkJoinPool p = null;
351        try {
352            p = new ForkJoinPool(2);
353            p.invoke(new FibTask(20));
354            assertTrue(p.getFactory() ==
355                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
356            Thread.sleep(MEDIUM_DELAY_MS);
278              assertTrue(p.isQuiescent());
358            assertTrue(p.getMaintainsParallelism());
279              assertFalse(p.getAsyncMode());
280 <            assertTrue(p.getActiveThreadCount() == 0);
281 <            assertTrue(p.getQueuedTaskCount() == 0);
282 <            assertTrue(p.getQueuedSubmissionCount() == 0);
280 >            assertEquals(0, p.getActiveThreadCount());
281 >            assertEquals(0, p.getQueuedTaskCount());
282 >            assertEquals(0, p.getQueuedSubmissionCount());
283              assertFalse(p.hasQueuedSubmissions());
284              assertFalse(p.isShutdown());
285              assertFalse(p.isTerminating());
286              assertFalse(p.isTerminated());
287 +            assertTrue(f.isDone());
288 +            assertEquals(6765, (int) f.get());
289          } finally {
290              joinPool(p);
291          }
# Line 373 | Line 295 | public class ForkJoinPoolTest extends JS
295       * Completed submit(ForkJoinTask) returns result
296       */
297      public void testSubmitForkJoinTask() throws Throwable {
298 <        ForkJoinPool p = null;
298 >        ForkJoinPool p = new ForkJoinPool(1);
299          try {
378            p = new ForkJoinPool(1);
300              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
301 <            int r = f.get();
381 <            assertTrue(r == 21);
301 >            assertEquals(21, (int) f.get());
302          } finally {
303              joinPool(p);
304          }
# Line 388 | Line 308 | public class ForkJoinPoolTest extends JS
308       * A task submitted after shutdown is rejected
309       */
310      public void testSubmitAfterShutdown() {
311 <        ForkJoinPool p = null;
311 >        ForkJoinPool p = new ForkJoinPool(1);
312          try {
393            p = new ForkJoinPool(1);
313              p.shutdown();
314              assertTrue(p.isShutdown());
315 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
316 <            shouldThrow();
317 <        } catch (RejectedExecutionException success) {
315 >            try {
316 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
317 >                shouldThrow();
318 >            } catch (RejectedExecutionException success) {}
319          } finally {
320              joinPool(p);
321          }
# Line 405 | Line 325 | public class ForkJoinPoolTest extends JS
325       * Pool maintains parallelism when using ManagedBlocker
326       */
327      public void testBlockingForkJoinTask() throws Throwable {
328 <        ForkJoinPool p = null;
328 >        ForkJoinPool p = new ForkJoinPool(4);
329          try {
410            p = new ForkJoinPool(4);
330              ReentrantLock lock = new ReentrantLock();
331              ManagedLocker locker = new ManagedLocker(lock);
332 <            ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
332 >            ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
333              p.execute(f);
334 <            assertTrue(p.getPoolSize() >= 4);
416 <            int r = f.get();
417 <            assertTrue(r ==  832040);
334 >            assertEquals(6765, (int) f.get());
335          } finally {
336              p.shutdownNow(); // don't wait out shutdown
337          }
# Line 424 | Line 341 | public class ForkJoinPoolTest extends JS
341       * pollSubmission returns unexecuted submitted task, if present
342       */
343      public void testPollSubmission() {
344 <        SubFJP p = null;
344 >        final CountDownLatch done = new CountDownLatch(1);
345 >        SubFJP p = new SubFJP();
346          try {
347 <            p = new SubFJP();
348 <            ForkJoinTask a = p.submit(new MediumRunnable());
349 <            ForkJoinTask b = p.submit(new MediumRunnable());
432 <            ForkJoinTask c = p.submit(new MediumRunnable());
347 >            ForkJoinTask a = p.submit(awaiter(done));
348 >            ForkJoinTask b = p.submit(awaiter(done));
349 >            ForkJoinTask c = p.submit(awaiter(done));
350              ForkJoinTask r = p.pollSubmission();
351              assertTrue(r == a || r == b || r == c);
352              assertFalse(r.isDone());
353          } finally {
354 +            done.countDown();
355              joinPool(p);
356          }
357      }
# Line 442 | Line 360 | public class ForkJoinPoolTest extends JS
360       * drainTasksTo transfers unexecuted submitted tasks, if present
361       */
362      public void testDrainTasksTo() {
363 <        SubFJP p = null;
363 >        final CountDownLatch done = new CountDownLatch(1);
364 >        SubFJP p = new SubFJP();
365          try {
366 <            p = new SubFJP();
367 <            ForkJoinTask a = p.submit(new MediumRunnable());
368 <            ForkJoinTask b = p.submit(new MediumRunnable());
450 <            ForkJoinTask c = p.submit(new MediumRunnable());
366 >            ForkJoinTask a = p.submit(awaiter(done));
367 >            ForkJoinTask b = p.submit(awaiter(done));
368 >            ForkJoinTask c = p.submit(awaiter(done));
369              ArrayList<ForkJoinTask> al = new ArrayList();
370              p.drainTasksTo(al);
371              assertTrue(al.size() > 0);
# Line 456 | Line 374 | public class ForkJoinPoolTest extends JS
374                  assertFalse(r.isDone());
375              }
376          } finally {
377 +            done.countDown();
378              joinPool(p);
379          }
380      }
381  
463
382      // FJ Versions of AbstractExecutorService tests
383  
384      /**
# Line 468 | Line 386 | public class ForkJoinPoolTest extends JS
386       */
387      public void testExecuteRunnable() throws Throwable {
388          ExecutorService e = new ForkJoinPool(1);
389 <        TrackedShortRunnable task = new TrackedShortRunnable();
390 <        assertFalse(task.done);
391 <        Future<?> future = e.submit(task);
392 <        future.get();
393 <        assertTrue(task.done);
389 >        try {
390 >            final AtomicBoolean done = new AtomicBoolean(false);
391 >            CheckedRunnable task = new CheckedRunnable() {
392 >                public void realRun() {
393 >                    done.set(true);
394 >                }};
395 >            Future<?> future = e.submit(task);
396 >            assertNull(future.get());
397 >            assertNull(future.get(0, MILLISECONDS));
398 >            assertTrue(done.get());
399 >            assertTrue(future.isDone());
400 >            assertFalse(future.isCancelled());
401 >        } finally {
402 >            joinPool(e);
403 >        }
404      }
405  
478
406      /**
407       * Completed submit(callable) returns result
408       */
409      public void testSubmitCallable() throws Throwable {
410          ExecutorService e = new ForkJoinPool(1);
411 <        Future<String> future = e.submit(new StringTask());
412 <        String result = future.get();
413 <        assertSame(TEST_STRING, result);
411 >        try {
412 >            Future<String> future = e.submit(new StringTask());
413 >            assertSame(TEST_STRING, future.get());
414 >            assertTrue(future.isDone());
415 >            assertFalse(future.isCancelled());
416 >        } finally {
417 >            joinPool(e);
418 >        }
419      }
420  
421      /**
# Line 491 | Line 423 | public class ForkJoinPoolTest extends JS
423       */
424      public void testSubmitRunnable() throws Throwable {
425          ExecutorService e = new ForkJoinPool(1);
426 <        Future<?> future = e.submit(new NoOpRunnable());
427 <        future.get();
428 <        assertTrue(future.isDone());
426 >        try {
427 >            Future<?> future = e.submit(new NoOpRunnable());
428 >            assertNull(future.get());
429 >            assertTrue(future.isDone());
430 >            assertFalse(future.isCancelled());
431 >        } finally {
432 >            joinPool(e);
433 >        }
434      }
435  
436      /**
# Line 501 | Line 438 | public class ForkJoinPoolTest extends JS
438       */
439      public void testSubmitRunnable2() throws Throwable {
440          ExecutorService e = new ForkJoinPool(1);
441 <        Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
442 <        String result = future.get();
443 <        assertSame(TEST_STRING, result);
441 >        try {
442 >            Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
443 >            assertSame(TEST_STRING, future.get());
444 >            assertTrue(future.isDone());
445 >            assertFalse(future.isCancelled());
446 >        } finally {
447 >            joinPool(e);
448 >        }
449      }
450  
509
451      /**
452 <     * A submitted privileged action to completion
452 >     * A submitted privileged action runs to completion
453       */
454 <    public void testSubmitPrivilegedAction() throws Throwable {
455 <        Policy savedPolicy = null;
456 <        try {
457 <            savedPolicy = Policy.getPolicy();
458 <            AdjustablePolicy policy = new AdjustablePolicy();
518 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
519 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
520 <            Policy.setPolicy(policy);
521 <        } catch (AccessControlException ok) {
522 <            return;
523 <        }
524 <        try {
525 <            ExecutorService e = new ForkJoinPool(1);
526 <            Future future = e.submit(Executors.callable(new PrivilegedAction() {
454 >    public void testSubmitPrivilegedAction() throws Exception {
455 >        Runnable r = new CheckedRunnable() {
456 >            public void realRun() throws Exception {
457 >                ExecutorService e = new ForkJoinPool(1);
458 >                Future future = e.submit(Executors.callable(new PrivilegedAction() {
459                      public Object run() {
460                          return TEST_STRING;
461                      }}));
462  
463 <            Object result = future.get();
464 <            assertSame(TEST_STRING, result);
465 <        }
466 <        finally {
467 <            Policy.setPolicy(savedPolicy);
536 <        }
463 >                assertSame(TEST_STRING, future.get());
464 >            }};
465 >
466 >        runWithPermissions(r,
467 >                           new RuntimePermission("modifyThread"));
468      }
469  
470      /**
471 <     * A submitted a privileged exception action runs to completion
471 >     * A submitted privileged exception action runs to completion
472       */
473 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
474 <        Policy savedPolicy = null;
475 <        try {
476 <            savedPolicy = Policy.getPolicy();
477 <            AdjustablePolicy policy = new AdjustablePolicy();
547 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
548 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
549 <            Policy.setPolicy(policy);
550 <        } catch (AccessControlException ok) {
551 <            return;
552 <        }
553 <
554 <        try {
555 <            ExecutorService e = new ForkJoinPool(1);
556 <            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
473 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
474 >        Runnable r = new CheckedRunnable() {
475 >            public void realRun() throws Exception {
476 >                ExecutorService e = new ForkJoinPool(1);
477 >                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
478                      public Object run() {
479                          return TEST_STRING;
480                      }}));
481  
482 <            Object result = future.get();
483 <            assertSame(TEST_STRING, result);
484 <        }
485 <        finally {
565 <            Policy.setPolicy(savedPolicy);
566 <        }
482 >                assertSame(TEST_STRING, future.get());
483 >            }};
484 >
485 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
486      }
487  
488      /**
489       * A submitted failed privileged exception action reports exception
490       */
491 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
492 <        Policy savedPolicy = null;
493 <        try {
494 <            savedPolicy = Policy.getPolicy();
495 <            AdjustablePolicy policy = new AdjustablePolicy();
577 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
578 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
579 <            Policy.setPolicy(policy);
580 <        } catch (AccessControlException ok) {
581 <            return;
582 <        }
583 <
584 <
585 <        try {
586 <            ExecutorService e = new ForkJoinPool(1);
587 <            Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
491 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
492 >        Runnable r = new CheckedRunnable() {
493 >            public void realRun() throws Exception {
494 >                ExecutorService e = new ForkJoinPool(1);
495 >                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
496                      public Object run() throws Exception {
497                          throw new IndexOutOfBoundsException();
498                      }}));
499  
500 <            Object result = future.get();
501 <            shouldThrow();
502 <        } catch (ExecutionException success) {
503 <        } finally {
504 <            Policy.setPolicy(savedPolicy);
505 <        }
500 >                try {
501 >                    future.get();
502 >                    shouldThrow();
503 >                } catch (ExecutionException success) {
504 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
505 >                }}};
506 >
507 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
508      }
509  
510      /**
511       * execute(null runnable) throws NullPointerException
512       */
513      public void testExecuteNullRunnable() {
514 +        ExecutorService e = new ForkJoinPool(1);
515          try {
516 <            ExecutorService e = new ForkJoinPool(1);
606 <            TrackedShortRunnable task = null;
607 <            Future<?> future = e.submit(task);
516 >            Future<?> future = e.submit((Runnable) null);
517              shouldThrow();
518          } catch (NullPointerException success) {
519 +        } finally {
520 +            joinPool(e);
521          }
522      }
523  
613
524      /**
525       * submit(null callable) throws NullPointerException
526       */
527      public void testSubmitNullCallable() {
528 +        ExecutorService e = new ForkJoinPool(1);
529          try {
530 <            ExecutorService e = new ForkJoinPool(1);
620 <            StringTask t = null;
621 <            Future<String> future = e.submit(t);
530 >            Future<String> future = e.submit((Callable) null);
531              shouldThrow();
532          } catch (NullPointerException success) {
533 +        } finally {
534 +            joinPool(e);
535          }
536      }
537  
627
538      /**
539 <     * Blocking on submit(callable) throws InterruptedException if
630 <     * caller interrupted.
539 >     * submit(callable).get() throws InterruptedException if interrupted
540       */
541      public void testInterruptedSubmit() throws InterruptedException {
542 <        final ForkJoinPool p = new ForkJoinPool(1);
543 <
544 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
545 <            void realRun() throws Throwable {
546 <                p.submit(new CheckedCallable<Object>() {
547 <                    public Object realCall() throws Throwable {
548 <                        try {
549 <                            Thread.sleep(MEDIUM_DELAY_MS);
550 <                        } catch (InterruptedException ok) {
551 <                        }
552 <                        return null;
553 <                    }}).get();
554 <            }});
555 <
556 <        t.start();
557 <        Thread.sleep(SHORT_DELAY_MS);
558 <        t.interrupt();
559 <        t.join();
560 <        p.shutdownNow();
561 <        joinPool(p);
542 >        final CountDownLatch submitted    = new CountDownLatch(1);
543 >        final CountDownLatch quittingTime = new CountDownLatch(1);
544 >        final ExecutorService p = new ForkJoinPool(1);
545 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
546 >            public Void realCall() throws InterruptedException {
547 >                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
548 >                return null;
549 >            }};
550 >        try {
551 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
552 >                public void realRun() throws Exception {
553 >                    Future<Void> future = p.submit(awaiter);
554 >                    submitted.countDown();
555 >                    future.get();
556 >                }});
557 >            t.start();
558 >            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
559 >            t.interrupt();
560 >            t.join();
561 >        } finally {
562 >            quittingTime.countDown();
563 >            joinPool(p);
564 >        }
565      }
566  
567      /**
# Line 666 | Line 578 | public class ForkJoinPoolTest extends JS
578                  }}).get();
579              shouldThrow();
580          } catch (ExecutionException success) {
581 +            assertTrue(success.getCause() instanceof ArithmeticException);
582 +        } finally {
583 +            joinPool(p);
584          }
670        joinPool(p);
585      }
586  
587      /**
# Line 699 | Line 613 | public class ForkJoinPoolTest extends JS
613      }
614  
615      /**
616 <     * invokeAny(c) throws NullPointerException if c has null elements
616 >     * invokeAny(c) throws NullPointerException if c has a single null element
617       */
618      public void testInvokeAny3() throws Throwable {
619          ExecutorService e = new ForkJoinPool(1);
620 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
621 +        l.add(null);
622          try {
707            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
708            l.add(new StringTask());
709            l.add(null);
623              e.invokeAny(l);
624              shouldThrow();
625          } catch (NullPointerException success) {
# Line 716 | Line 629 | public class ForkJoinPoolTest extends JS
629      }
630  
631      /**
632 <     * invokeAny(c) throws ExecutionException if no task in c completes
632 >     * invokeAny(c) throws NullPointerException if c has null elements
633       */
634      public void testInvokeAny4() throws Throwable {
635 +        CountDownLatch latch = new CountDownLatch(1);
636 +        ExecutorService e = new ForkJoinPool(1);
637 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
638 +        l.add(latchAwaitingStringTask(latch));
639 +        l.add(null);
640 +        try {
641 +            e.invokeAny(l);
642 +            shouldThrow();
643 +        } catch (NullPointerException success) {
644 +        } finally {
645 +            latch.countDown();
646 +            joinPool(e);
647 +        }
648 +    }
649 +
650 +    /**
651 +     * invokeAny(c) throws ExecutionException if no task in c completes
652 +     */
653 +    public void testInvokeAny5() throws Throwable {
654          ExecutorService e = new ForkJoinPool(1);
655 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
656 +        l.add(new NPETask());
657          try {
724            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
725            l.add(new NPETask());
658              e.invokeAny(l);
659              shouldThrow();
660          } catch (ExecutionException success) {
661 +            assertTrue(success.getCause() instanceof NullPointerException);
662          } finally {
663              joinPool(e);
664          }
# Line 734 | Line 667 | public class ForkJoinPoolTest extends JS
667      /**
668       * invokeAny(c) returns result of some task in c if at least one completes
669       */
670 <    public void testInvokeAny5() throws Throwable {
670 >    public void testInvokeAny6() throws Throwable {
671          ExecutorService e = new ForkJoinPool(1);
672          try {
673 <            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
673 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
674              l.add(new StringTask());
675              l.add(new StringTask());
676              String result = e.invokeAny(l);
# Line 780 | Line 713 | public class ForkJoinPoolTest extends JS
713       */
714      public void testInvokeAll3() throws InterruptedException {
715          ExecutorService e = new ForkJoinPool(1);
716 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
717 +        l.add(new StringTask());
718 +        l.add(null);
719          try {
784            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
785            l.add(new StringTask());
786            l.add(null);
720              e.invokeAll(l);
721              shouldThrow();
722          } catch (NullPointerException success) {
# Line 798 | Line 731 | public class ForkJoinPoolTest extends JS
731       */
732      public void testInvokeAll4() throws Throwable {
733          ExecutorService e = new ForkJoinPool(1);
734 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
735 +        l.add(new NPETask());
736 +        List<Future<String>> futures = e.invokeAll(l);
737 +        assertEquals(1, futures.size());
738          try {
739 <            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
803 <            l.add(new NPETask());
804 <            List<Future<String>> result = e.invokeAll(l);
805 <            assertEquals(1, result.size());
806 <            for (Future<String> future : result)
807 <                future.get();
739 >            futures.get(0).get();
740              shouldThrow();
741          } catch (ExecutionException success) {
742 +            assertTrue(success.getCause() instanceof NullPointerException);
743          } finally {
744              joinPool(e);
745          }
# Line 818 | Line 751 | public class ForkJoinPoolTest extends JS
751      public void testInvokeAll5() throws Throwable {
752          ExecutorService e = new ForkJoinPool(1);
753          try {
754 <            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
754 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
755              l.add(new StringTask());
756              l.add(new StringTask());
757 <            List<Future<String>> result = e.invokeAll(l);
758 <            assertEquals(2, result.size());
759 <            for (Future<String> future : result)
757 >            List<Future<String>> futures = e.invokeAll(l);
758 >            assertEquals(2, futures.size());
759 >            for (Future<String> future : futures)
760                  assertSame(TEST_STRING, future.get());
761          } finally {
762              joinPool(e);
763          }
764      }
765  
833
766      /**
767       * timed invokeAny(null) throws NullPointerException
768       */
# Line 850 | Line 782 | public class ForkJoinPoolTest extends JS
782       */
783      public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
784          ExecutorService e = new ForkJoinPool(1);
785 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
786 +        l.add(new StringTask());
787          try {
854            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
855            l.add(new StringTask());
788              e.invokeAny(l, MEDIUM_DELAY_MS, null);
789              shouldThrow();
790          } catch (NullPointerException success) {
# Line 880 | Line 812 | public class ForkJoinPoolTest extends JS
812       * timed invokeAny(c) throws NullPointerException if c has null elements
813       */
814      public void testTimedInvokeAny3() throws Throwable {
815 +        CountDownLatch latch = new CountDownLatch(1);
816          ExecutorService e = new ForkJoinPool(1);
817 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
818 +        l.add(latchAwaitingStringTask(latch));
819 +        l.add(null);
820          try {
885            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
886            l.add(new StringTask());
887            l.add(null);
821              e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
822              shouldThrow();
823          } catch (NullPointerException success) {
824          } finally {
825 +            latch.countDown();
826              joinPool(e);
827          }
828      }
# Line 898 | Line 832 | public class ForkJoinPoolTest extends JS
832       */
833      public void testTimedInvokeAny4() throws Throwable {
834          ExecutorService e = new ForkJoinPool(1);
835 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
836 +        l.add(new NPETask());
837          try {
902            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
903            l.add(new NPETask());
838              e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
839              shouldThrow();
840          } catch (ExecutionException success) {
841 +            assertTrue(success.getCause() instanceof NullPointerException);
842          } finally {
843              joinPool(e);
844          }
# Line 915 | Line 850 | public class ForkJoinPoolTest extends JS
850      public void testTimedInvokeAny5() throws Throwable {
851          ExecutorService e = new ForkJoinPool(1);
852          try {
853 <            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
853 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
854              l.add(new StringTask());
855              l.add(new StringTask());
856              String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
# Line 944 | Line 879 | public class ForkJoinPoolTest extends JS
879       */
880      public void testTimedInvokeAllNullTimeUnit() throws Throwable {
881          ExecutorService e = new ForkJoinPool(1);
882 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
883 +        l.add(new StringTask());
884          try {
948            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
949            l.add(new StringTask());
885              e.invokeAll(l, MEDIUM_DELAY_MS, null);
886              shouldThrow();
887          } catch (NullPointerException success) {
# Line 975 | Line 910 | public class ForkJoinPoolTest extends JS
910       */
911      public void testTimedInvokeAll3() throws InterruptedException {
912          ExecutorService e = new ForkJoinPool(1);
913 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
914 +        l.add(new StringTask());
915 +        l.add(null);
916          try {
979            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
980            l.add(new StringTask());
981            l.add(null);
917              e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
918              shouldThrow();
919          } catch (NullPointerException success) {
# Line 992 | Line 927 | public class ForkJoinPoolTest extends JS
927       */
928      public void testTimedInvokeAll4() throws Throwable {
929          ExecutorService e = new ForkJoinPool(1);
930 +        List<Callable<String>> l = new ArrayList<Callable<String>>();
931 +        l.add(new NPETask());
932 +        List<Future<String>> futures
933 +            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
934 +        assertEquals(1, futures.size());
935          try {
936 <            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
997 <            l.add(new NPETask());
998 <            List<Future<String>> result
999 <                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1000 <            assertEquals(1, result.size());
1001 <            for (Future<String> future : result)
1002 <                future.get();
936 >            futures.get(0).get();
937              shouldThrow();
938          } catch (ExecutionException success) {
939 +            assertTrue(success.getCause() instanceof NullPointerException);
940          } finally {
941              joinPool(e);
942          }
# Line 1013 | Line 948 | public class ForkJoinPoolTest extends JS
948      public void testTimedInvokeAll5() throws Throwable {
949          ExecutorService e = new ForkJoinPool(1);
950          try {
951 <            ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
951 >            List<Callable<String>> l = new ArrayList<Callable<String>>();
952              l.add(new StringTask());
953              l.add(new StringTask());
954 <            List<Future<String>> result
954 >            List<Future<String>> futures
955                  = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
956 <            assertEquals(2, result.size());
957 <            for (Future<String> future : result)
956 >            assertEquals(2, futures.size());
957 >            for (Future<String> future : futures)
958                  assertSame(TEST_STRING, future.get());
959          } finally {
960              joinPool(e);

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines