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.24 by jsr166, Mon Sep 13 15:34:42 2010 UTC vs.
Revision 1.36 by jsr166, Mon Nov 29 07:42:58 2010 UTC

# Line 5 | Line 5
5   */
6  
7   import junit.framework.*;
8 < import java.util.*;
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;
# Line 21 | Line 23 | import java.util.concurrent.ForkJoinWork
23   import java.util.concurrent.RecursiveTask;
24   import java.util.concurrent.TimeUnit;
25   import java.util.concurrent.locks.ReentrantLock;
26 + import static java.util.concurrent.TimeUnit.MILLISECONDS;
27   import java.security.AccessControlException;
28   import java.security.Policy;
29   import java.security.PrivilegedAction;
# Line 159 | Line 162 | public class ForkJoinPoolTest extends JS
162      public void testDefaultInitialState() {
163          ForkJoinPool p = new ForkJoinPool(1);
164          try {
165 <            assertTrue(p.getFactory() ==
166 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
165 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
166 >                       p.getFactory());
167              assertTrue(p.isQuiescent());
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 203 | Line 206 | public class ForkJoinPoolTest extends JS
206      public void testGetParallelism() {
207          ForkJoinPool p = new ForkJoinPool(1);
208          try {
209 <            assertTrue(p.getParallelism() == 1);
209 >            assertEquals(1, p.getParallelism());
210          } finally {
211              joinPool(p);
212          }
# Line 215 | Line 218 | public class ForkJoinPoolTest extends JS
218      public void testGetPoolSize() {
219          ForkJoinPool p = new ForkJoinPool(1);
220          try {
221 <            assertTrue(p.getActiveThreadCount() == 0);
221 >            assertEquals(0, p.getActiveThreadCount());
222              Future<String> future = p.submit(new StringTask());
223 <            assertTrue(p.getPoolSize() == 1);
223 >            assertEquals(1, p.getPoolSize());
224          } finally {
225              joinPool(p);
226          }
# Line 230 | Line 233 | public class ForkJoinPoolTest extends JS
233       * performs its defined action
234       */
235      public void testSetUncaughtExceptionHandler() throws InterruptedException {
236 <        MyHandler eh = new MyHandler();
237 <        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(), eh, false);
238 <        try {
239 <            assert(eh == p.getUncaughtExceptionHandler());
240 <            p.execute(new FailingTask());
241 <            Thread.sleep(MEDIUM_DELAY_MS);
242 <            assertTrue(eh.catches > 0);
236 >        final CountDownLatch uehInvoked = new CountDownLatch(1);
237 >        final Thread.UncaughtExceptionHandler eh =
238 >            new Thread.UncaughtExceptionHandler() {
239 >                public void uncaughtException(Thread t, Throwable e) {
240 >                    uehInvoked.countDown();
241 >                }};
242 >        ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
243 >                                          eh, false);
244 >        try {
245 >            assertSame(eh, p.getUncaughtExceptionHandler());
246 >            p.execute(new FibTask(8));
247 >            assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
248          } finally {
249 <            p.shutdownNow();
249 >            p.shutdownNow(); // failure might have prevented processing task
250              joinPool(p);
251          }
252      }
# Line 251 | Line 259 | public class ForkJoinPoolTest extends JS
259      public void testisQuiescent() throws InterruptedException {
260          ForkJoinPool p = new ForkJoinPool(2);
261          try {
262 +            assertTrue(p.isQuiescent());
263              p.invoke(new FibTask(20));
264 <            assertTrue(p.getFactory() ==
265 <                       ForkJoinPool.defaultForkJoinWorkerThreadFactory);
266 <            Thread.sleep(MEDIUM_DELAY_MS);
264 >            assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
265 >                       p.getFactory());
266 >            Thread.sleep(SMALL_DELAY_MS);
267              assertTrue(p.isQuiescent());
268              assertFalse(p.getAsyncMode());
269 <            assertTrue(p.getActiveThreadCount() == 0);
270 <            assertTrue(p.getQueuedTaskCount() == 0);
271 <            assertTrue(p.getQueuedSubmissionCount() == 0);
269 >            assertEquals(0, p.getActiveThreadCount());
270 >            assertEquals(0, p.getQueuedTaskCount());
271 >            assertEquals(0, p.getQueuedSubmissionCount());
272              assertFalse(p.hasQueuedSubmissions());
273              assertFalse(p.isShutdown());
274              assertFalse(p.isTerminating());
# Line 276 | Line 285 | public class ForkJoinPoolTest extends JS
285          ForkJoinPool p = new ForkJoinPool(1);
286          try {
287              ForkJoinTask<Integer> f = p.submit(new FibTask(8));
288 <            int r = f.get();
280 <            assertTrue(r == 21);
288 >            assertEquals(21, (int) f.get());
289          } finally {
290              joinPool(p);
291          }
# Line 291 | Line 299 | public class ForkJoinPoolTest extends JS
299          try {
300              p.shutdown();
301              assertTrue(p.isShutdown());
302 <            ForkJoinTask<Integer> f = p.submit(new FibTask(8));
303 <            shouldThrow();
304 <        } catch (RejectedExecutionException success) {
302 >            try {
303 >                ForkJoinTask<Integer> f = p.submit(new FibTask(8));
304 >                shouldThrow();
305 >            } catch (RejectedExecutionException success) {}
306          } finally {
307              joinPool(p);
308          }
# Line 307 | Line 316 | public class ForkJoinPoolTest extends JS
316          try {
317              ReentrantLock lock = new ReentrantLock();
318              ManagedLocker locker = new ManagedLocker(lock);
319 <            ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
319 >            ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
320              p.execute(f);
321 <            int r = f.get();
313 <            assertTrue(r == 832040);
321 >            assertEquals(6765, (int) f.get());
322          } finally {
323              p.shutdownNow(); // don't wait out shutdown
324          }
# Line 320 | Line 328 | public class ForkJoinPoolTest extends JS
328       * pollSubmission returns unexecuted submitted task, if present
329       */
330      public void testPollSubmission() {
331 +        final CountDownLatch done = new CountDownLatch(1);
332          SubFJP p = new SubFJP();
333          try {
334 <            ForkJoinTask a = p.submit(new MediumRunnable());
335 <            ForkJoinTask b = p.submit(new MediumRunnable());
336 <            ForkJoinTask c = p.submit(new MediumRunnable());
334 >            ForkJoinTask a = p.submit(awaiter(done));
335 >            ForkJoinTask b = p.submit(awaiter(done));
336 >            ForkJoinTask c = p.submit(awaiter(done));
337              ForkJoinTask r = p.pollSubmission();
338              assertTrue(r == a || r == b || r == c);
339              assertFalse(r.isDone());
340          } finally {
341 +            done.countDown();
342              joinPool(p);
343          }
344      }
# Line 337 | Line 347 | public class ForkJoinPoolTest extends JS
347       * drainTasksTo transfers unexecuted submitted tasks, if present
348       */
349      public void testDrainTasksTo() {
350 +        final CountDownLatch done = new CountDownLatch(1);
351          SubFJP p = new SubFJP();
352          try {
353 <            ForkJoinTask a = p.submit(new MediumRunnable());
354 <            ForkJoinTask b = p.submit(new MediumRunnable());
355 <            ForkJoinTask c = p.submit(new MediumRunnable());
353 >            ForkJoinTask a = p.submit(awaiter(done));
354 >            ForkJoinTask b = p.submit(awaiter(done));
355 >            ForkJoinTask c = p.submit(awaiter(done));
356              ArrayList<ForkJoinTask> al = new ArrayList();
357              p.drainTasksTo(al);
358              assertTrue(al.size() > 0);
# Line 350 | Line 361 | public class ForkJoinPoolTest extends JS
361                  assertFalse(r.isDone());
362              }
363          } finally {
364 +            done.countDown();
365              joinPool(p);
366          }
367      }
# Line 363 | Line 375 | public class ForkJoinPoolTest extends JS
375      public void testExecuteRunnable() throws Throwable {
376          ExecutorService e = new ForkJoinPool(1);
377          try {
378 <            TrackedShortRunnable task = new TrackedShortRunnable();
379 <            assertFalse(task.done);
378 >            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
379 >            assertFalse(task.isDone());
380              Future<?> future = e.submit(task);
381 <            future.get();
382 <            assertTrue(task.done);
381 >            assertNull(future.get());
382 >            assertNull(future.get(MEDIUM_DELAY_MS, MILLISECONDS));
383 >            assertTrue(task.isDone());
384 >            assertTrue(future.isDone());
385 >            assertFalse(future.isCancelled());
386          } finally {
387              joinPool(e);
388          }
# Line 381 | Line 396 | public class ForkJoinPoolTest extends JS
396          ExecutorService e = new ForkJoinPool(1);
397          try {
398              Future<String> future = e.submit(new StringTask());
399 <            String result = future.get();
400 <            assertSame(TEST_STRING, result);
399 >            assertSame(TEST_STRING, future.get());
400 >            assertTrue(future.isDone());
401 >            assertFalse(future.isCancelled());
402          } finally {
403              joinPool(e);
404          }
# Line 395 | Line 411 | public class ForkJoinPoolTest extends JS
411          ExecutorService e = new ForkJoinPool(1);
412          try {
413              Future<?> future = e.submit(new NoOpRunnable());
414 <            future.get();
414 >            assertNull(future.get());
415              assertTrue(future.isDone());
416 +            assertFalse(future.isCancelled());
417          } finally {
418              joinPool(e);
419          }
# Line 409 | Line 426 | public class ForkJoinPoolTest extends JS
426          ExecutorService e = new ForkJoinPool(1);
427          try {
428              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
429 <            String result = future.get();
430 <            assertSame(TEST_STRING, result);
429 >            assertSame(TEST_STRING, future.get());
430 >            assertTrue(future.isDone());
431 >            assertFalse(future.isCancelled());
432          } finally {
433              joinPool(e);
434          }
435      }
436  
419
437      /**
438 <     * A submitted privileged action to completion
438 >     * A submitted privileged action runs to completion
439       */
440 <    public void testSubmitPrivilegedAction() throws Throwable {
441 <        Policy savedPolicy = null;
442 <        try {
443 <            savedPolicy = Policy.getPolicy();
427 <            AdjustablePolicy policy = new AdjustablePolicy();
428 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
429 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
430 <            Policy.setPolicy(policy);
431 <        } catch (AccessControlException ok) {
432 <            return;
433 <        }
434 <
435 <        try {
436 <            ExecutorService e = new ForkJoinPool(1);
437 <            try {
440 >    public void testSubmitPrivilegedAction() throws Exception {
441 >        Runnable r = new CheckedRunnable() {
442 >            public void realRun() throws Exception {
443 >                ExecutorService e = new ForkJoinPool(1);
444                  Future future = e.submit(Executors.callable(new PrivilegedAction() {
445                      public Object run() {
446                          return TEST_STRING;
447                      }}));
448  
449 <                Object result = future.get();
450 <                assertSame(TEST_STRING, result);
451 <            } finally {
452 <                joinPool(e);
453 <            }
448 <        } finally {
449 <            Policy.setPolicy(savedPolicy);
450 <        }
449 >                assertSame(TEST_STRING, future.get());
450 >            }};
451 >
452 >        runWithPermissions(r,
453 >                           new RuntimePermission("modifyThread"));
454      }
455  
456      /**
457 <     * A submitted a privileged exception action runs to completion
457 >     * A submitted privileged exception action runs to completion
458       */
459 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
460 <        Policy savedPolicy = null;
461 <        try {
462 <            savedPolicy = Policy.getPolicy();
460 <            AdjustablePolicy policy = new AdjustablePolicy();
461 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
462 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
463 <            Policy.setPolicy(policy);
464 <        } catch (AccessControlException ok) {
465 <            return;
466 <        }
467 <
468 <        try {
469 <            ExecutorService e = new ForkJoinPool(1);
470 <            try {
459 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
460 >        Runnable r = new CheckedRunnable() {
461 >            public void realRun() throws Exception {
462 >                ExecutorService e = new ForkJoinPool(1);
463                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
464                      public Object run() {
465                          return TEST_STRING;
466                      }}));
467  
468 <                Object result = future.get();
469 <                assertSame(TEST_STRING, result);
470 <            } finally {
471 <                joinPool(e);
480 <            }
481 <        } finally {
482 <            Policy.setPolicy(savedPolicy);
483 <        }
468 >                assertSame(TEST_STRING, future.get());
469 >            }};
470 >
471 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
472      }
473  
474      /**
475       * A submitted failed privileged exception action reports exception
476       */
477 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
478 <        Policy savedPolicy = null;
479 <        try {
480 <            savedPolicy = Policy.getPolicy();
493 <            AdjustablePolicy policy = new AdjustablePolicy();
494 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
495 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
496 <            Policy.setPolicy(policy);
497 <        } catch (AccessControlException ok) {
498 <            return;
499 <        }
500 <
501 <        try {
502 <            ExecutorService e = new ForkJoinPool(1);
503 <            try {
477 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
478 >        Runnable r = new CheckedRunnable() {
479 >            public void realRun() throws Exception {
480 >                ExecutorService e = new ForkJoinPool(1);
481                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
482                      public Object run() throws Exception {
483                          throw new IndexOutOfBoundsException();
484                      }}));
485  
486 <                Object result = future.get();
487 <                shouldThrow();
488 <            } catch (ExecutionException success) {
489 <                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
490 <            } finally {
491 <                joinPool(e);
492 <            }
493 <        } finally {
517 <            Policy.setPolicy(savedPolicy);
518 <        }
486 >                try {
487 >                    future.get();
488 >                    shouldThrow();
489 >                } catch (ExecutionException success) {
490 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
491 >                }}};
492 >
493 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
494      }
495  
496      /**
# Line 524 | Line 499 | public class ForkJoinPoolTest extends JS
499      public void testExecuteNullRunnable() {
500          ExecutorService e = new ForkJoinPool(1);
501          try {
502 <            TrackedShortRunnable task = null;
528 <            Future<?> future = e.submit(task);
502 >            Future<?> future = e.submit((Runnable) null);
503              shouldThrow();
504          } catch (NullPointerException success) {
505          } finally {
# Line 540 | Line 514 | public class ForkJoinPoolTest extends JS
514      public void testSubmitNullCallable() {
515          ExecutorService e = new ForkJoinPool(1);
516          try {
517 <            StringTask t = null;
544 <            Future<String> future = e.submit(t);
517 >            Future<String> future = e.submit((Callable) null);
518              shouldThrow();
519          } catch (NullPointerException success) {
520          } finally {
# Line 551 | Line 524 | public class ForkJoinPoolTest extends JS
524  
525  
526      /**
527 <     * Blocking on submit(callable) throws InterruptedException if
555 <     * caller interrupted.
527 >     * submit(callable).get() throws InterruptedException if interrupted
528       */
529      public void testInterruptedSubmit() throws InterruptedException {
530 <        final ForkJoinPool p = new ForkJoinPool(1);
531 <
532 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
533 <            public void realRun() throws Throwable {
534 <                p.submit(new CheckedCallable<Object>() {
535 <                    public Object realCall() throws Throwable {
536 <                        try {
537 <                            Thread.sleep(MEDIUM_DELAY_MS);
538 <                        } catch (InterruptedException ok) {
539 <                        }
540 <                        return null;
541 <                    }}).get();
542 <            }});
543 <
544 <        t.start();
545 <        Thread.sleep(SHORT_DELAY_MS);
546 <        t.interrupt();
547 <        t.join();
548 <        p.shutdownNow();
549 <        joinPool(p);
530 >        final CountDownLatch submitted    = new CountDownLatch(1);
531 >        final CountDownLatch quittingTime = new CountDownLatch(1);
532 >        final ExecutorService p = new ForkJoinPool(1);
533 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
534 >            public Void realCall() throws InterruptedException {
535 >                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
536 >                return null;
537 >            }};
538 >        try {
539 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
540 >                public void realRun() throws Exception {
541 >                    Future<Void> future = p.submit(awaiter);
542 >                    submitted.countDown();
543 >                    future.get();
544 >                }});
545 >            t.start();
546 >            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
547 >            t.interrupt();
548 >            t.join();
549 >        } finally {
550 >            quittingTime.countDown();
551 >            joinPool(p);
552 >        }
553      }
554  
555      /**
# Line 783 | Line 758 | public class ForkJoinPoolTest extends JS
758      public void testTimedInvokeAny1() throws Throwable {
759          ExecutorService e = new ForkJoinPool(1);
760          try {
761 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
761 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
762              shouldThrow();
763          } catch (NullPointerException success) {
764          } finally {
# Line 814 | Line 789 | public class ForkJoinPoolTest extends JS
789          ExecutorService e = new ForkJoinPool(1);
790          try {
791              e.invokeAny(new ArrayList<Callable<String>>(),
792 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
792 >                        MEDIUM_DELAY_MS, MILLISECONDS);
793              shouldThrow();
794          } catch (IllegalArgumentException success) {
795          } finally {
# Line 832 | Line 807 | public class ForkJoinPoolTest extends JS
807          l.add(latchAwaitingStringTask(latch));
808          l.add(null);
809          try {
810 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
810 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
811              shouldThrow();
812          } catch (NullPointerException success) {
813          } finally {
# Line 849 | Line 824 | public class ForkJoinPoolTest extends JS
824          List<Callable<String>> l = new ArrayList<Callable<String>>();
825          l.add(new NPETask());
826          try {
827 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
827 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
828              shouldThrow();
829          } catch (ExecutionException success) {
830              assertTrue(success.getCause() instanceof NullPointerException);
# Line 867 | Line 842 | public class ForkJoinPoolTest extends JS
842              List<Callable<String>> l = new ArrayList<Callable<String>>();
843              l.add(new StringTask());
844              l.add(new StringTask());
845 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
845 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
846              assertSame(TEST_STRING, result);
847          } finally {
848              joinPool(e);
# Line 880 | Line 855 | public class ForkJoinPoolTest extends JS
855      public void testTimedInvokeAll1() throws Throwable {
856          ExecutorService e = new ForkJoinPool(1);
857          try {
858 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
858 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
859              shouldThrow();
860          } catch (NullPointerException success) {
861          } finally {
# Line 912 | Line 887 | public class ForkJoinPoolTest extends JS
887          try {
888              List<Future<String>> r
889                  = e.invokeAll(new ArrayList<Callable<String>>(),
890 <                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
890 >                              MEDIUM_DELAY_MS, MILLISECONDS);
891              assertTrue(r.isEmpty());
892          } finally {
893              joinPool(e);
# Line 928 | Line 903 | public class ForkJoinPoolTest extends JS
903          l.add(new StringTask());
904          l.add(null);
905          try {
906 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
906 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
907              shouldThrow();
908          } catch (NullPointerException success) {
909          } finally {
# Line 944 | Line 919 | public class ForkJoinPoolTest extends JS
919          List<Callable<String>> l = new ArrayList<Callable<String>>();
920          l.add(new NPETask());
921          List<Future<String>> futures
922 <            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
922 >            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
923          assertEquals(1, futures.size());
924          try {
925              futures.get(0).get();
# Line 966 | Line 941 | public class ForkJoinPoolTest extends JS
941              l.add(new StringTask());
942              l.add(new StringTask());
943              List<Future<String>> futures
944 <                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
944 >                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
945              assertEquals(2, futures.size());
946              for (Future<String> future : futures)
947                  assertSame(TEST_STRING, future.get());

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines