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.31 by jsr166, Sat Oct 9 19:46:42 2010 UTC vs.
Revision 1.41 by jsr166, Fri May 27 19:42:42 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   import junit.framework.*;
# Line 164 | Line 164 | public class ForkJoinPoolTest extends JS
164          try {
165              assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
166                         p.getFactory());
167 –            assertTrue(p.isQuiescent());
167              assertFalse(p.getAsyncMode());
168              assertEquals(0, p.getActiveThreadCount());
169              assertEquals(0, p.getStealCount());
# Line 199 | Line 198 | public class ForkJoinPoolTest extends JS
198          } catch (NullPointerException success) {}
199      }
200  
202 –
201      /**
202       * getParallelism returns size set in constructor
203       */
# Line 252 | Line 250 | public class ForkJoinPoolTest extends JS
250      }
251  
252      /**
253 <     * After invoking a single task, isQuiescent is true,
254 <     * queues are empty, threads are not active, and
255 <     * construction parameters continue to hold
253 >     * After invoking a single task, isQuiescent eventually becomes
254 >     * true, at which time queues are empty, threads are not active,
255 >     * the task has completed successfully, and construction
256 >     * parameters continue to hold
257       */
258 <    public void testisQuiescent() throws InterruptedException {
258 >    public void testisQuiescent() throws Exception {
259          ForkJoinPool p = new ForkJoinPool(2);
260          try {
261              assertTrue(p.isQuiescent());
262 <            p.invoke(new FibTask(20));
262 >            long startTime = System.nanoTime();
263 >            FibTask f = new FibTask(20);
264 >            p.invoke(f);
265              assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
266                         p.getFactory());
267 <            Thread.sleep(SMALL_DELAY_MS);
267 >            while (! p.isQuiescent()) {
268 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
269 >                    throw new AssertionFailedError("timed out");
270 >                assertFalse(p.getAsyncMode());
271 >                assertFalse(p.isShutdown());
272 >                assertFalse(p.isTerminating());
273 >                assertFalse(p.isTerminated());
274 >                Thread.yield();
275 >            }
276 >
277              assertTrue(p.isQuiescent());
278              assertFalse(p.getAsyncMode());
279              assertEquals(0, p.getActiveThreadCount());
# Line 273 | Line 283 | public class ForkJoinPoolTest extends JS
283              assertFalse(p.isShutdown());
284              assertFalse(p.isTerminating());
285              assertFalse(p.isTerminated());
286 +            assertTrue(f.isDone());
287 +            assertEquals(6765, (int) f.get());
288          } finally {
289              joinPool(p);
290          }
# Line 316 | Line 328 | public class ForkJoinPoolTest extends JS
328          try {
329              ReentrantLock lock = new ReentrantLock();
330              ManagedLocker locker = new ManagedLocker(lock);
331 <            ForkJoinTask<Integer> f = new LockingFibTask(30, locker, lock);
331 >            ForkJoinTask<Integer> f = new LockingFibTask(20, locker, lock);
332              p.execute(f);
333 <            assertEquals(832040, (int) f.get());
333 >            assertEquals(6765, (int) f.get());
334          } finally {
335              p.shutdownNow(); // don't wait out shutdown
336          }
# Line 328 | Line 340 | public class ForkJoinPoolTest extends JS
340       * pollSubmission returns unexecuted submitted task, if present
341       */
342      public void testPollSubmission() {
343 +        final CountDownLatch done = new CountDownLatch(1);
344          SubFJP p = new SubFJP();
345          try {
346 <            ForkJoinTask a = p.submit(new MediumRunnable());
347 <            ForkJoinTask b = p.submit(new MediumRunnable());
348 <            ForkJoinTask c = p.submit(new MediumRunnable());
346 >            ForkJoinTask a = p.submit(awaiter(done));
347 >            ForkJoinTask b = p.submit(awaiter(done));
348 >            ForkJoinTask c = p.submit(awaiter(done));
349              ForkJoinTask r = p.pollSubmission();
350              assertTrue(r == a || r == b || r == c);
351              assertFalse(r.isDone());
352          } finally {
353 +            done.countDown();
354              joinPool(p);
355          }
356      }
# Line 345 | Line 359 | public class ForkJoinPoolTest extends JS
359       * drainTasksTo transfers unexecuted submitted tasks, if present
360       */
361      public void testDrainTasksTo() {
362 +        final CountDownLatch done = new CountDownLatch(1);
363          SubFJP p = new SubFJP();
364          try {
365 <            ForkJoinTask a = p.submit(new MediumRunnable());
366 <            ForkJoinTask b = p.submit(new MediumRunnable());
367 <            ForkJoinTask c = p.submit(new MediumRunnable());
365 >            ForkJoinTask a = p.submit(awaiter(done));
366 >            ForkJoinTask b = p.submit(awaiter(done));
367 >            ForkJoinTask c = p.submit(awaiter(done));
368              ArrayList<ForkJoinTask> al = new ArrayList();
369              p.drainTasksTo(al);
370              assertTrue(al.size() > 0);
# Line 358 | Line 373 | public class ForkJoinPoolTest extends JS
373                  assertFalse(r.isDone());
374              }
375          } finally {
376 +            done.countDown();
377              joinPool(p);
378          }
379      }
380  
365 –
381      // FJ Versions of AbstractExecutorService tests
382  
383      /**
# Line 371 | Line 386 | public class ForkJoinPoolTest extends JS
386      public void testExecuteRunnable() throws Throwable {
387          ExecutorService e = new ForkJoinPool(1);
388          try {
389 <            TrackedShortRunnable task = new TrackedShortRunnable();
390 <            assertFalse(task.done);
389 >            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
390 >            assertFalse(task.isDone());
391              Future<?> future = e.submit(task);
392 <            future.get();
393 <            assertTrue(task.done);
392 >            assertNull(future.get());
393 >            assertNull(future.get(MEDIUM_DELAY_MS, MILLISECONDS));
394 >            assertTrue(task.isDone());
395 >            assertTrue(future.isDone());
396 >            assertFalse(future.isCancelled());
397          } finally {
398              joinPool(e);
399          }
400      }
401  
384 –
402      /**
403       * Completed submit(callable) returns result
404       */
# Line 389 | Line 406 | public class ForkJoinPoolTest extends JS
406          ExecutorService e = new ForkJoinPool(1);
407          try {
408              Future<String> future = e.submit(new StringTask());
409 <            String result = future.get();
410 <            assertSame(TEST_STRING, result);
409 >            assertSame(TEST_STRING, future.get());
410 >            assertTrue(future.isDone());
411 >            assertFalse(future.isCancelled());
412          } finally {
413              joinPool(e);
414          }
# Line 403 | Line 421 | public class ForkJoinPoolTest extends JS
421          ExecutorService e = new ForkJoinPool(1);
422          try {
423              Future<?> future = e.submit(new NoOpRunnable());
424 <            future.get();
424 >            assertNull(future.get());
425              assertTrue(future.isDone());
426 +            assertFalse(future.isCancelled());
427          } finally {
428              joinPool(e);
429          }
# Line 417 | Line 436 | public class ForkJoinPoolTest extends JS
436          ExecutorService e = new ForkJoinPool(1);
437          try {
438              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
439 <            String result = future.get();
440 <            assertSame(TEST_STRING, result);
439 >            assertSame(TEST_STRING, future.get());
440 >            assertTrue(future.isDone());
441 >            assertFalse(future.isCancelled());
442          } finally {
443              joinPool(e);
444          }
445      }
446  
427 –
447      /**
448 <     * A submitted privileged action to completion
448 >     * A submitted privileged action runs to completion
449       */
450 <    public void testSubmitPrivilegedAction() throws Throwable {
451 <        Policy savedPolicy = null;
452 <        try {
453 <            savedPolicy = Policy.getPolicy();
435 <            AdjustablePolicy policy = new AdjustablePolicy();
436 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
437 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
438 <            Policy.setPolicy(policy);
439 <        } catch (AccessControlException ok) {
440 <            return;
441 <        }
442 <
443 <        try {
444 <            ExecutorService e = new ForkJoinPool(1);
445 <            try {
450 >    public void testSubmitPrivilegedAction() throws Exception {
451 >        Runnable r = new CheckedRunnable() {
452 >            public void realRun() throws Exception {
453 >                ExecutorService e = new ForkJoinPool(1);
454                  Future future = e.submit(Executors.callable(new PrivilegedAction() {
455                      public Object run() {
456                          return TEST_STRING;
457                      }}));
458  
459 <                Object result = future.get();
460 <                assertSame(TEST_STRING, result);
461 <            } finally {
462 <                joinPool(e);
463 <            }
456 <        } finally {
457 <            Policy.setPolicy(savedPolicy);
458 <        }
459 >                assertSame(TEST_STRING, future.get());
460 >            }};
461 >
462 >        runWithPermissions(r,
463 >                           new RuntimePermission("modifyThread"));
464      }
465  
466      /**
467 <     * A submitted a privileged exception action runs to completion
467 >     * A submitted privileged exception action runs to completion
468       */
469 <    public void testSubmitPrivilegedExceptionAction() throws Throwable {
470 <        Policy savedPolicy = null;
471 <        try {
472 <            savedPolicy = Policy.getPolicy();
468 <            AdjustablePolicy policy = new AdjustablePolicy();
469 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
470 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
471 <            Policy.setPolicy(policy);
472 <        } catch (AccessControlException ok) {
473 <            return;
474 <        }
475 <
476 <        try {
477 <            ExecutorService e = new ForkJoinPool(1);
478 <            try {
469 >    public void testSubmitPrivilegedExceptionAction() throws Exception {
470 >        Runnable r = new CheckedRunnable() {
471 >            public void realRun() throws Exception {
472 >                ExecutorService e = new ForkJoinPool(1);
473                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
474                      public Object run() {
475                          return TEST_STRING;
476                      }}));
477  
478 <                Object result = future.get();
479 <                assertSame(TEST_STRING, result);
480 <            } finally {
481 <                joinPool(e);
488 <            }
489 <        } finally {
490 <            Policy.setPolicy(savedPolicy);
491 <        }
478 >                assertSame(TEST_STRING, future.get());
479 >            }};
480 >
481 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
482      }
483  
484      /**
485       * A submitted failed privileged exception action reports exception
486       */
487 <    public void testSubmitFailedPrivilegedExceptionAction() throws Throwable {
488 <        Policy savedPolicy = null;
489 <        try {
490 <            savedPolicy = Policy.getPolicy();
501 <            AdjustablePolicy policy = new AdjustablePolicy();
502 <            policy.addPermission(new RuntimePermission("getContextClassLoader"));
503 <            policy.addPermission(new RuntimePermission("setContextClassLoader"));
504 <            Policy.setPolicy(policy);
505 <        } catch (AccessControlException ok) {
506 <            return;
507 <        }
508 <
509 <        try {
510 <            ExecutorService e = new ForkJoinPool(1);
511 <            try {
487 >    public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
488 >        Runnable r = new CheckedRunnable() {
489 >            public void realRun() throws Exception {
490 >                ExecutorService e = new ForkJoinPool(1);
491                  Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
492                      public Object run() throws Exception {
493                          throw new IndexOutOfBoundsException();
494                      }}));
495  
496 <                Object result = future.get();
497 <                shouldThrow();
498 <            } catch (ExecutionException success) {
499 <                assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
500 <            } finally {
501 <                joinPool(e);
502 <            }
503 <        } finally {
525 <            Policy.setPolicy(savedPolicy);
526 <        }
496 >                try {
497 >                    future.get();
498 >                    shouldThrow();
499 >                } catch (ExecutionException success) {
500 >                    assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
501 >                }}};
502 >
503 >        runWithPermissions(r, new RuntimePermission("modifyThread"));
504      }
505  
506      /**
# Line 540 | Line 517 | public class ForkJoinPoolTest extends JS
517          }
518      }
519  
543 –
520      /**
521       * submit(null callable) throws NullPointerException
522       */
# Line 555 | Line 531 | public class ForkJoinPoolTest extends JS
531          }
532      }
533  
558 –
534      /**
535       * submit(callable).get() throws InterruptedException if interrupted
536       */
# Line 784 | Line 759 | public class ForkJoinPoolTest extends JS
759          }
760      }
761  
787 –
762      /**
763       * timed invokeAny(null) throws NullPointerException
764       */

Diff Legend

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