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.26 by jsr166, Thu Sep 16 00:52:49 2010 UTC vs.
Revision 1.34 by jsr166, Thu Nov 18 19:14:34 2010 UTC

# Line 23 | 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 232 | Line 233 | public class ForkJoinPoolTest extends JS
233       * performs its defined action
234       */
235      public void testSetUncaughtExceptionHandler() throws InterruptedException {
236 <        MyHandler eh = new MyHandler();
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 FailingTask());
247 <            Thread.sleep(MEDIUM_DELAY_MS);
242 <            assertTrue(eh.catches > 0);
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 254 | 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              assertSame(ForkJoinPool.defaultForkJoinWorkerThreadFactory,
265                         p.getFactory());
266 <            Thread.sleep(MEDIUM_DELAY_MS);
266 >            Thread.sleep(SMALL_DELAY_MS);
267              assertTrue(p.isQuiescent());
268              assertFalse(p.getAsyncMode());
269              assertEquals(0, p.getActiveThreadCount());
# Line 310 | 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 <            assertEquals(832040, (int) f.get());
321 >            assertEquals(6765, (int) f.get());
322          } finally {
323              p.shutdownNow(); // don't wait out shutdown
324          }
# Line 324 | Line 330 | public class ForkJoinPoolTest extends JS
330      public void testPollSubmission() {
331          SubFJP p = new SubFJP();
332          try {
333 <            ForkJoinTask a = p.submit(new MediumRunnable());
334 <            ForkJoinTask b = p.submit(new MediumRunnable());
335 <            ForkJoinTask c = p.submit(new MediumRunnable());
333 >            ForkJoinTask a = p.submit(new ShortRunnable());
334 >            ForkJoinTask b = p.submit(new ShortRunnable());
335 >            ForkJoinTask c = p.submit(new ShortRunnable());
336              ForkJoinTask r = p.pollSubmission();
337              assertTrue(r == a || r == b || r == c);
338              assertFalse(r.isDone());
# Line 341 | Line 347 | public class ForkJoinPoolTest extends JS
347      public void testDrainTasksTo() {
348          SubFJP p = new SubFJP();
349          try {
350 <            ForkJoinTask a = p.submit(new MediumRunnable());
351 <            ForkJoinTask b = p.submit(new MediumRunnable());
352 <            ForkJoinTask c = p.submit(new MediumRunnable());
350 >            ForkJoinTask a = p.submit(new ShortRunnable());
351 >            ForkJoinTask b = p.submit(new ShortRunnable());
352 >            ForkJoinTask c = p.submit(new ShortRunnable());
353              ArrayList<ForkJoinTask> al = new ArrayList();
354              p.drainTasksTo(al);
355              assertTrue(al.size() > 0);
# Line 365 | Line 371 | public class ForkJoinPoolTest extends JS
371      public void testExecuteRunnable() throws Throwable {
372          ExecutorService e = new ForkJoinPool(1);
373          try {
374 <            TrackedShortRunnable task = new TrackedShortRunnable();
375 <            assertFalse(task.done);
374 >            TrackedRunnable task = trackedRunnable(SHORT_DELAY_MS);
375 >            assertFalse(task.isDone());
376              Future<?> future = e.submit(task);
377 <            future.get();
378 <            assertTrue(task.done);
377 >            assertNull(future.get());
378 >            assertTrue(task.isDone());
379 >            assertFalse(future.isCancelled());
380          } finally {
381              joinPool(e);
382          }
# Line 383 | Line 390 | public class ForkJoinPoolTest extends JS
390          ExecutorService e = new ForkJoinPool(1);
391          try {
392              Future<String> future = e.submit(new StringTask());
393 <            String result = future.get();
394 <            assertSame(TEST_STRING, result);
393 >            assertSame(TEST_STRING, future.get());
394 >            assertTrue(future.isDone());
395 >            assertFalse(future.isCancelled());
396          } finally {
397              joinPool(e);
398          }
# Line 397 | Line 405 | public class ForkJoinPoolTest extends JS
405          ExecutorService e = new ForkJoinPool(1);
406          try {
407              Future<?> future = e.submit(new NoOpRunnable());
408 <            future.get();
408 >            assertNull(future.get());
409              assertTrue(future.isDone());
410 +            assertFalse(future.isCancelled());
411          } finally {
412              joinPool(e);
413          }
# Line 411 | Line 420 | public class ForkJoinPoolTest extends JS
420          ExecutorService e = new ForkJoinPool(1);
421          try {
422              Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
423 <            String result = future.get();
424 <            assertSame(TEST_STRING, result);
423 >            assertSame(TEST_STRING, future.get());
424 >            assertTrue(future.isDone());
425 >            assertFalse(future.isCancelled());
426          } finally {
427              joinPool(e);
428          }
# Line 420 | Line 430 | public class ForkJoinPoolTest extends JS
430  
431  
432      /**
433 <     * A submitted privileged action to completion
433 >     * A submitted privileged action runs to completion
434       */
435      public void testSubmitPrivilegedAction() throws Throwable {
436          Policy savedPolicy = null;
# Line 453 | Line 463 | public class ForkJoinPoolTest extends JS
463      }
464  
465      /**
466 <     * A submitted a privileged exception action runs to completion
466 >     * A submitted privileged exception action runs to completion
467       */
468      public void testSubmitPrivilegedExceptionAction() throws Throwable {
469          Policy savedPolicy = null;
# Line 525 | Line 535 | public class ForkJoinPoolTest extends JS
535       */
536      public void testExecuteNullRunnable() {
537          ExecutorService e = new ForkJoinPool(1);
528 –        TrackedShortRunnable task = null;
538          try {
539 <            Future<?> future = e.submit(task);
539 >            Future<?> future = e.submit((Runnable) null);
540              shouldThrow();
541          } catch (NullPointerException success) {
542          } finally {
# Line 541 | Line 550 | public class ForkJoinPoolTest extends JS
550       */
551      public void testSubmitNullCallable() {
552          ExecutorService e = new ForkJoinPool(1);
544 –        StringTask t = null;
553          try {
554 <            Future<String> future = e.submit(t);
554 >            Future<String> future = e.submit((Callable) null);
555              shouldThrow();
556          } catch (NullPointerException success) {
557          } finally {
# Line 553 | Line 561 | public class ForkJoinPoolTest extends JS
561  
562  
563      /**
564 <     * Blocking on submit(callable) throws InterruptedException if
557 <     * caller interrupted.
564 >     * submit(callable).get() throws InterruptedException if interrupted
565       */
566      public void testInterruptedSubmit() throws InterruptedException {
567 <        final ForkJoinPool p = new ForkJoinPool(1);
568 <
569 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
570 <            public void realRun() throws Throwable {
571 <                p.submit(new CheckedCallable<Object>() {
572 <                    public Object realCall() throws Throwable {
573 <                        try {
574 <                            Thread.sleep(MEDIUM_DELAY_MS);
575 <                        } catch (InterruptedException ok) {
576 <                        }
577 <                        return null;
578 <                    }}).get();
579 <            }});
580 <
581 <        t.start();
582 <        Thread.sleep(SHORT_DELAY_MS);
583 <        t.interrupt();
584 <        t.join();
585 <        p.shutdownNow();
586 <        joinPool(p);
567 >        final CountDownLatch submitted    = new CountDownLatch(1);
568 >        final CountDownLatch quittingTime = new CountDownLatch(1);
569 >        final ExecutorService p = new ForkJoinPool(1);
570 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
571 >            public Void realCall() throws InterruptedException {
572 >                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
573 >                return null;
574 >            }};
575 >        try {
576 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
577 >                public void realRun() throws Exception {
578 >                    Future<Void> future = p.submit(awaiter);
579 >                    submitted.countDown();
580 >                    future.get();
581 >                }});
582 >            t.start();
583 >            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
584 >            t.interrupt();
585 >            t.join();
586 >        } finally {
587 >            quittingTime.countDown();
588 >            joinPool(p);
589 >        }
590      }
591  
592      /**
# Line 785 | Line 795 | public class ForkJoinPoolTest extends JS
795      public void testTimedInvokeAny1() throws Throwable {
796          ExecutorService e = new ForkJoinPool(1);
797          try {
798 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
798 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
799              shouldThrow();
800          } catch (NullPointerException success) {
801          } finally {
# Line 816 | Line 826 | public class ForkJoinPoolTest extends JS
826          ExecutorService e = new ForkJoinPool(1);
827          try {
828              e.invokeAny(new ArrayList<Callable<String>>(),
829 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
829 >                        MEDIUM_DELAY_MS, MILLISECONDS);
830              shouldThrow();
831          } catch (IllegalArgumentException success) {
832          } finally {
# Line 834 | Line 844 | public class ForkJoinPoolTest extends JS
844          l.add(latchAwaitingStringTask(latch));
845          l.add(null);
846          try {
847 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
847 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
848              shouldThrow();
849          } catch (NullPointerException success) {
850          } finally {
# Line 851 | Line 861 | public class ForkJoinPoolTest extends JS
861          List<Callable<String>> l = new ArrayList<Callable<String>>();
862          l.add(new NPETask());
863          try {
864 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
864 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
865              shouldThrow();
866          } catch (ExecutionException success) {
867              assertTrue(success.getCause() instanceof NullPointerException);
# Line 869 | Line 879 | public class ForkJoinPoolTest extends JS
879              List<Callable<String>> l = new ArrayList<Callable<String>>();
880              l.add(new StringTask());
881              l.add(new StringTask());
882 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
882 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
883              assertSame(TEST_STRING, result);
884          } finally {
885              joinPool(e);
# Line 882 | Line 892 | public class ForkJoinPoolTest extends JS
892      public void testTimedInvokeAll1() throws Throwable {
893          ExecutorService e = new ForkJoinPool(1);
894          try {
895 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
895 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
896              shouldThrow();
897          } catch (NullPointerException success) {
898          } finally {
# Line 914 | Line 924 | public class ForkJoinPoolTest extends JS
924          try {
925              List<Future<String>> r
926                  = e.invokeAll(new ArrayList<Callable<String>>(),
927 <                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
927 >                              MEDIUM_DELAY_MS, MILLISECONDS);
928              assertTrue(r.isEmpty());
929          } finally {
930              joinPool(e);
# Line 930 | Line 940 | public class ForkJoinPoolTest extends JS
940          l.add(new StringTask());
941          l.add(null);
942          try {
943 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
943 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
944              shouldThrow();
945          } catch (NullPointerException success) {
946          } finally {
# Line 946 | Line 956 | public class ForkJoinPoolTest extends JS
956          List<Callable<String>> l = new ArrayList<Callable<String>>();
957          l.add(new NPETask());
958          List<Future<String>> futures
959 <            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
959 >            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
960          assertEquals(1, futures.size());
961          try {
962              futures.get(0).get();
# Line 968 | Line 978 | public class ForkJoinPoolTest extends JS
978              l.add(new StringTask());
979              l.add(new StringTask());
980              List<Future<String>> futures
981 <                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
981 >                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
982              assertEquals(2, futures.size());
983              for (Future<String> future : futures)
984                  assertSame(TEST_STRING, future.get());

Diff Legend

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