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.34 by jsr166, Thu Nov 18 19:14:34 2010 UTC vs.
Revision 1.48 by jsr166, Wed Feb 6 16:36:36 2013 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   import junit.framework.*;
# Line 22 | Line 22 | 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.security.AccessControlException;
# Line 164 | Line 165 | public class ForkJoinPoolTest extends JS
165          try {
166              assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
167                         p.getFactory());
167 –            assertTrue(p.isQuiescent());
168              assertFalse(p.getAsyncMode());
169              assertEquals(0, p.getActiveThreadCount());
170              assertEquals(0, p.getStealCount());
# Line 199 | Line 199 | public class ForkJoinPoolTest extends JS
199          } catch (NullPointerException success) {}
200      }
201  
202 –
202      /**
203       * getParallelism returns size set in constructor
204       */
# Line 243 | Line 242 | public class ForkJoinPoolTest extends JS
242                                            eh, false);
243          try {
244              assertSame(eh, p.getUncaughtExceptionHandler());
245 <            p.execute(new FibTask(8));
246 <            assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
245 >            try {
246 >                p.execute(new FibTask(8));
247 >                assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
248 >            } catch (RejectedExecutionException ok) {
249 >            }
250          } finally {
251              p.shutdownNow(); // failure might have prevented processing task
252              joinPool(p);
# Line 252 | Line 254 | public class ForkJoinPoolTest extends JS
254      }
255  
256      /**
257 <     * After invoking a single task, isQuiescent is true,
258 <     * queues are empty, threads are not active, and
259 <     * construction parameters continue to hold
257 >     * After invoking a single task, isQuiescent eventually becomes
258 >     * true, at which time queues are empty, threads are not active,
259 >     * the task has completed successfully, and construction
260 >     * parameters continue to hold
261       */
262 <    public void testisQuiescent() throws InterruptedException {
262 >    public void testIsQuiescent() throws Exception {
263          ForkJoinPool p = new ForkJoinPool(2);
264          try {
265              assertTrue(p.isQuiescent());
266 <            p.invoke(new FibTask(20));
266 >            long startTime = System.nanoTime();
267 >            FibTask f = new FibTask(20);
268 >            p.invoke(f);
269              assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
270                         p.getFactory());
271 <            Thread.sleep(SMALL_DELAY_MS);
271 >            while (! p.isQuiescent()) {
272 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
273 >                    throw new AssertionFailedError("timed out");
274 >                assertFalse(p.getAsyncMode());
275 >                assertFalse(p.isShutdown());
276 >                assertFalse(p.isTerminating());
277 >                assertFalse(p.isTerminated());
278 >                Thread.yield();
279 >            }
280 >
281              assertTrue(p.isQuiescent());
282              assertFalse(p.getAsyncMode());
283              assertEquals(0, p.getActiveThreadCount());
# Line 273 | Line 287 | public class ForkJoinPoolTest extends JS
287              assertFalse(p.isShutdown());
288              assertFalse(p.isTerminating());
289              assertFalse(p.isTerminated());
290 +            assertTrue(f.isDone());
291 +            assertEquals(6765, (int) f.get());
292          } finally {
293              joinPool(p);
294          }
# Line 328 | Line 344 | public class ForkJoinPoolTest extends JS
344       * pollSubmission returns unexecuted submitted task, if present
345       */
346      public void testPollSubmission() {
347 +        final CountDownLatch done = new CountDownLatch(1);
348          SubFJP p = new SubFJP();
349          try {
350 <            ForkJoinTask a = p.submit(new ShortRunnable());
351 <            ForkJoinTask b = p.submit(new ShortRunnable());
352 <            ForkJoinTask c = p.submit(new ShortRunnable());
350 >            ForkJoinTask a = p.submit(awaiter(done));
351 >            ForkJoinTask b = p.submit(awaiter(done));
352 >            ForkJoinTask c = p.submit(awaiter(done));
353              ForkJoinTask r = p.pollSubmission();
354              assertTrue(r == a || r == b || r == c);
355              assertFalse(r.isDone());
356          } finally {
357 +            done.countDown();
358              joinPool(p);
359          }
360      }
# Line 345 | Line 363 | public class ForkJoinPoolTest extends JS
363       * drainTasksTo transfers unexecuted submitted tasks, if present
364       */
365      public void testDrainTasksTo() {
366 +        final CountDownLatch done = new CountDownLatch(1);
367          SubFJP p = new SubFJP();
368          try {
369 <            ForkJoinTask a = p.submit(new ShortRunnable());
370 <            ForkJoinTask b = p.submit(new ShortRunnable());
371 <            ForkJoinTask c = p.submit(new ShortRunnable());
369 >            ForkJoinTask a = p.submit(awaiter(done));
370 >            ForkJoinTask b = p.submit(awaiter(done));
371 >            ForkJoinTask c = p.submit(awaiter(done));
372              ArrayList<ForkJoinTask> al = new ArrayList();
373              p.drainTasksTo(al);
374              assertTrue(al.size() > 0);
# Line 358 | Line 377 | public class ForkJoinPoolTest extends JS
377                  assertFalse(r.isDone());
378              }
379          } finally {
380 +            done.countDown();
381              joinPool(p);
382          }
383      }
384  
365 –
385      // FJ Versions of AbstractExecutorService tests
386  
387      /**
# Line 371 | Line 390 | public class ForkJoinPoolTest extends JS
390      public void testExecuteRunnable() throws Throwable {
391          ExecutorService e = new ForkJoinPool(1);
392          try {
393 <            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
394 <            assertFalse(task.isDone());
393 >            final AtomicBoolean done = new AtomicBoolean(false);
394 >            CheckedRunnable task = new CheckedRunnable() {
395 >                public void realRun() {
396 >                    done.set(true);
397 >                }};
398              Future<?> future = e.submit(task);
399              assertNull(future.get());
400 <            assertTrue(task.isDone());
400 >            assertNull(future.get(0, MILLISECONDS));
401 >            assertTrue(done.get());
402 >            assertTrue(future.isDone());
403              assertFalse(future.isCancelled());
404          } finally {
405              joinPool(e);
406          }
407      }
408  
385 –
409      /**
410       * Completed submit(callable) returns result
411       */
# Line 428 | Line 451 | public class ForkJoinPoolTest extends JS
451          }
452      }
453  
431 –
454      /**
455       * A submitted privileged action runs to completion
456       */
457 <    public void testSubmitPrivilegedAction() throws Throwable {
458 <        Policy savedPolicy = null;
459 <        try {
460 <            savedPolicy = Policy.getPolicy();
461 <            AdjustablePolicy policy = new AdjustablePolicy();
440 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
441 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
442 <            Policy.setPolicy(policy);
443 <        } catch (AccessControlException ok) {
444 <            return;
445 <        }
446 <
447 <        try {
457 >    public void testSubmitPrivilegedAction() throws Exception {
458 >        final Callable callable = Executors.callable(new PrivilegedAction() {
459 >                public Object run() { return TEST_STRING; }});
460 >        Runnable r = new CheckedRunnable() {
461 >        public void realRun() throws Exception {
462              ExecutorService e = new ForkJoinPool(1);
463              try {
464 <                Future future = e.submit(Executors.callable(new PrivilegedAction() {
465 <                    public Object run() {
452 <                        return TEST_STRING;
453 <                    }}));
454 <
455 <                Object result = future.get();
456 <                assertSame(TEST_STRING, result);
464 >                Future future = e.submit(callable);
465 >                assertSame(TEST_STRING, future.get());
466              } finally {
467                  joinPool(e);
468              }
469 <        } finally {
470 <            Policy.setPolicy(savedPolicy);
471 <        }
469 >        }};
470 >
471 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
472      }
473  
474      /**
475       * A submitted privileged exception action runs to completion
476       */
477 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
478 <        Policy savedPolicy = null;
479 <        try {
480 <            savedPolicy = Policy.getPolicy();
481 <            AdjustablePolicy policy = new AdjustablePolicy();
482 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
474 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
475 <            Policy.setPolicy(policy);
476 <        } catch (AccessControlException ok) {
477 <            return;
478 <        }
479 <
480 <        try {
477 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
478 >        final Callable callable =
479 >            Executors.callable(new PrivilegedExceptionAction() {
480 >                public Object run() { return TEST_STRING; }});
481 >        Runnable r = new CheckedRunnable() {
482 >        public void realRun() throws Exception {
483              ExecutorService e = new ForkJoinPool(1);
484              try {
485 <                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
486 <                    public Object run() {
485 <                        return TEST_STRING;
486 <                    }}));
487 <
488 <                Object result = future.get();
489 <                assertSame(TEST_STRING, result);
485 >                Future future = e.submit(callable);
486 >                assertSame(TEST_STRING, future.get());
487              } finally {
488                  joinPool(e);
489              }
490 <        } finally {
491 <            Policy.setPolicy(savedPolicy);
492 <        }
490 >        }};
491 >
492 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
493      }
494  
495      /**
496       * A submitted failed privileged exception action reports exception
497       */
498 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
499 <        Policy savedPolicy = null;
500 <        try {
501 <            savedPolicy = Policy.getPolicy();
502 <            AdjustablePolicy policy = new AdjustablePolicy();
503 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
507 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
508 <            Policy.setPolicy(policy);
509 <        } catch (AccessControlException ok) {
510 <            return;
511 <        }
512 <
513 <        try {
498 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
499 >        final Callable callable =
500 >            Executors.callable(new PrivilegedExceptionAction() {
501 >                public Object run() { throw new IndexOutOfBoundsException(); }});
502 >        Runnable r = new CheckedRunnable() {
503 >        public void realRun() throws Exception {
504              ExecutorService e = new ForkJoinPool(1);
505              try {
506 <                Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
507 <                    public Object run() throws Exception {
508 <                        throw new IndexOutOfBoundsException();
509 <                    }}));
510 <
511 <                Object result = future.get();
512 <                shouldThrow();
523 <            } catch (ExecutionException success) {
524 <                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
506 >                Future future = e.submit(callable);
507 >                try {
508 >                    future.get();
509 >                    shouldThrow();
510 >                } catch (ExecutionException success) {
511 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
512 >                }
513              } finally {
514                  joinPool(e);
515              }
516 <        } finally {
517 <            Policy.setPolicy(savedPolicy);
518 <        }
516 >        }};
517 >
518 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
519      }
520  
521      /**
# Line 544 | Line 532 | public class ForkJoinPoolTest extends JS
532          }
533      }
534  
547 –
535      /**
536       * submit(null callable) throws NullPointerException
537       */
# Line 559 | Line 546 | public class ForkJoinPoolTest extends JS
546          }
547      }
548  
562 –
549      /**
550       * submit(callable).get() throws InterruptedException if interrupted
551       */
# Line 597 | Line 583 | public class ForkJoinPoolTest extends JS
583          ForkJoinPool p = new ForkJoinPool(1);
584          try {
585              p.submit(new Callable() {
586 <                public Object call() {
587 <                    int i = 5/0;
602 <                    return Boolean.TRUE;
603 <                }}).get();
586 >                public Object call() { throw new ArithmeticException(); }})
587 >                .get();
588              shouldThrow();
589          } catch (ExecutionException success) {
590              assertTrue(success.getCause() instanceof ArithmeticException);
# Line 788 | Line 772 | public class ForkJoinPoolTest extends JS
772          }
773      }
774  
791 –
775      /**
776       * timed invokeAny(null) throws NullPointerException
777       */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines