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.31 by jsr166, Sat Oct 9 19:46:42 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 525 | Line 531 | public class ForkJoinPoolTest extends JS
531       */
532      public void testExecuteNullRunnable() {
533          ExecutorService e = new ForkJoinPool(1);
528 –        TrackedShortRunnable task = null;
534          try {
535 <            Future<?> future = e.submit(task);
535 >            Future<?> future = e.submit((Runnable) null);
536              shouldThrow();
537          } catch (NullPointerException success) {
538          } finally {
# Line 541 | Line 546 | public class ForkJoinPoolTest extends JS
546       */
547      public void testSubmitNullCallable() {
548          ExecutorService e = new ForkJoinPool(1);
544 –        StringTask t = null;
549          try {
550 <            Future<String> future = e.submit(t);
550 >            Future<String> future = e.submit((Callable) null);
551              shouldThrow();
552          } catch (NullPointerException success) {
553          } finally {
# Line 553 | Line 557 | public class ForkJoinPoolTest extends JS
557  
558  
559      /**
560 <     * Blocking on submit(callable) throws InterruptedException if
557 <     * caller interrupted.
560 >     * submit(callable).get() throws InterruptedException if interrupted
561       */
562      public void testInterruptedSubmit() throws InterruptedException {
563 <        final ForkJoinPool p = new ForkJoinPool(1);
564 <
565 <        Thread t = new Thread(new CheckedInterruptedRunnable() {
566 <            public void realRun() throws Throwable {
567 <                p.submit(new CheckedCallable<Object>() {
568 <                    public Object realCall() throws Throwable {
569 <                        try {
570 <                            Thread.sleep(MEDIUM_DELAY_MS);
571 <                        } catch (InterruptedException ok) {
572 <                        }
573 <                        return null;
574 <                    }}).get();
575 <            }});
576 <
577 <        t.start();
578 <        Thread.sleep(SHORT_DELAY_MS);
579 <        t.interrupt();
580 <        t.join();
581 <        p.shutdownNow();
582 <        joinPool(p);
563 >        final CountDownLatch submitted    = new CountDownLatch(1);
564 >        final CountDownLatch quittingTime = new CountDownLatch(1);
565 >        final ExecutorService p = new ForkJoinPool(1);
566 >        final Callable<Void> awaiter = new CheckedCallable<Void>() {
567 >            public Void realCall() throws InterruptedException {
568 >                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
569 >                return null;
570 >            }};
571 >        try {
572 >            Thread t = new Thread(new CheckedInterruptedRunnable() {
573 >                public void realRun() throws Exception {
574 >                    Future<Void> future = p.submit(awaiter);
575 >                    submitted.countDown();
576 >                    future.get();
577 >                }});
578 >            t.start();
579 >            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
580 >            t.interrupt();
581 >            t.join();
582 >        } finally {
583 >            quittingTime.countDown();
584 >            joinPool(p);
585 >        }
586      }
587  
588      /**
# Line 785 | Line 791 | public class ForkJoinPoolTest extends JS
791      public void testTimedInvokeAny1() throws Throwable {
792          ExecutorService e = new ForkJoinPool(1);
793          try {
794 <            e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
794 >            e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
795              shouldThrow();
796          } catch (NullPointerException success) {
797          } finally {
# Line 816 | Line 822 | public class ForkJoinPoolTest extends JS
822          ExecutorService e = new ForkJoinPool(1);
823          try {
824              e.invokeAny(new ArrayList<Callable<String>>(),
825 <                        MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
825 >                        MEDIUM_DELAY_MS, MILLISECONDS);
826              shouldThrow();
827          } catch (IllegalArgumentException success) {
828          } finally {
# Line 834 | Line 840 | public class ForkJoinPoolTest extends JS
840          l.add(latchAwaitingStringTask(latch));
841          l.add(null);
842          try {
843 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
843 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
844              shouldThrow();
845          } catch (NullPointerException success) {
846          } finally {
# Line 851 | Line 857 | public class ForkJoinPoolTest extends JS
857          List<Callable<String>> l = new ArrayList<Callable<String>>();
858          l.add(new NPETask());
859          try {
860 <            e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
860 >            e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
861              shouldThrow();
862          } catch (ExecutionException success) {
863              assertTrue(success.getCause() instanceof NullPointerException);
# Line 869 | Line 875 | public class ForkJoinPoolTest extends JS
875              List<Callable<String>> l = new ArrayList<Callable<String>>();
876              l.add(new StringTask());
877              l.add(new StringTask());
878 <            String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
878 >            String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
879              assertSame(TEST_STRING, result);
880          } finally {
881              joinPool(e);
# Line 882 | Line 888 | public class ForkJoinPoolTest extends JS
888      public void testTimedInvokeAll1() throws Throwable {
889          ExecutorService e = new ForkJoinPool(1);
890          try {
891 <            e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
891 >            e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
892              shouldThrow();
893          } catch (NullPointerException success) {
894          } finally {
# Line 914 | Line 920 | public class ForkJoinPoolTest extends JS
920          try {
921              List<Future<String>> r
922                  = e.invokeAll(new ArrayList<Callable<String>>(),
923 <                              MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
923 >                              MEDIUM_DELAY_MS, MILLISECONDS);
924              assertTrue(r.isEmpty());
925          } finally {
926              joinPool(e);
# Line 930 | Line 936 | public class ForkJoinPoolTest extends JS
936          l.add(new StringTask());
937          l.add(null);
938          try {
939 <            e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
939 >            e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
940              shouldThrow();
941          } catch (NullPointerException success) {
942          } finally {
# Line 946 | Line 952 | public class ForkJoinPoolTest extends JS
952          List<Callable<String>> l = new ArrayList<Callable<String>>();
953          l.add(new NPETask());
954          List<Future<String>> futures
955 <            = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
955 >            = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
956          assertEquals(1, futures.size());
957          try {
958              futures.get(0).get();
# Line 968 | Line 974 | public class ForkJoinPoolTest extends JS
974              l.add(new StringTask());
975              l.add(new StringTask());
976              List<Future<String>> futures
977 <                = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
977 >                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
978              assertEquals(2, futures.size());
979              for (Future<String> future : futures)
980                  assertSame(TEST_STRING, future.get());

Diff Legend

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