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.62 by jsr166, Sun Oct 4 07:42:07 2015 UTC vs.
Revision 1.67 by jsr166, Thu Oct 8 03:03:36 2015 UTC

# Line 64 | Line 64 | public class ForkJoinPoolTest extends JS
64          }
65      }
66  
67 +    static class MyError extends Error {}
68 +
69      // to test handlers
70      static class FailingFJWSubclass extends ForkJoinWorkerThread {
71          public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
72 <        protected void onStart() { super.onStart(); throw new Error(); }
72 >        protected void onStart() { super.onStart(); throw new MyError(); }
73      }
74  
75      static class FailingThreadFactory
# Line 256 | Line 258 | public class ForkJoinPoolTest extends JS
258       */
259      public void testSetUncaughtExceptionHandler() throws InterruptedException {
260          final CountDownLatch uehInvoked = new CountDownLatch(1);
261 <        final Thread.UncaughtExceptionHandler eh =
261 >        final Thread.UncaughtExceptionHandler ueh =
262              new Thread.UncaughtExceptionHandler() {
263                  public void uncaughtException(Thread t, Throwable e) {
264 +                    threadAssertTrue(e instanceof MyError);
265 +                    threadAssertTrue(t instanceof FailingFJWSubclass);
266                      uehInvoked.countDown();
267                  }};
268          ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
269 <                                          eh, false);
270 <        try {
271 <            assertSame(eh, p.getUncaughtExceptionHandler());
269 >                                          ueh, false);
270 >        try (PoolCleaner cleaner = cleaner(p)) {
271 >            assertSame(ueh, p.getUncaughtExceptionHandler());
272              try {
273                  p.execute(new FibTask(8));
274 <                assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
275 <            } catch (RejectedExecutionException ok) {
274 >                await(uehInvoked);
275 >            } finally {
276 >                p.shutdownNow(); // failure might have prevented processing task
277              }
273 –        } finally {
274 –            p.shutdownNow(); // failure might have prevented processing task
275 –            joinPool(p);
278          }
279      }
280  
# Line 548 | Line 550 | public class ForkJoinPoolTest extends JS
550      public void testInterruptedSubmit() throws InterruptedException {
551          final CountDownLatch submitted    = new CountDownLatch(1);
552          final CountDownLatch quittingTime = new CountDownLatch(1);
551 –        final ExecutorService p = new ForkJoinPool(1);
553          final Callable<Void> awaiter = new CheckedCallable<Void>() {
554              public Void realCall() throws InterruptedException {
555 <                assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
555 >                assertTrue(quittingTime.await(2*LONG_DELAY_MS, MILLISECONDS));
556                  return null;
557              }};
558 <        try {
558 >        final ExecutorService p = new ForkJoinPool(1);
559 >        try (PoolCleaner cleaner = cleaner(p, quittingTime)) {
560              Thread t = new Thread(new CheckedInterruptedRunnable() {
561                  public void realRun() throws Exception {
562                      Future<Void> future = p.submit(awaiter);
# Line 562 | Line 564 | public class ForkJoinPoolTest extends JS
564                      future.get();
565                  }});
566              t.start();
567 <            assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
567 >            await(submitted);
568              t.interrupt();
569 <            t.join();
568 <        } finally {
569 <            quittingTime.countDown();
570 <            joinPool(p);
569 >            awaitTermination(t);
570          }
571      }
572  
# Line 822 | Line 821 | public class ForkJoinPoolTest extends JS
821      public void testTimedInvokeAny4() throws Throwable {
822          ExecutorService e = new ForkJoinPool(1);
823          try (PoolCleaner cleaner = cleaner(e)) {
824 +            long startTime = System.nanoTime();
825              List<Callable<String>> l = new ArrayList<Callable<String>>();
826              l.add(new NPETask());
827              try {
828 <                e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
828 >                e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
829                  shouldThrow();
830              } catch (ExecutionException success) {
831                  assertTrue(success.getCause() instanceof NullPointerException);
832              }
833 +            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
834          }
835      }
836  
# Line 913 | Line 914 | public class ForkJoinPoolTest extends JS
914              List<Callable<String>> l = new ArrayList<Callable<String>>();
915              l.add(new NPETask());
916              List<Future<String>> futures
917 <                = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
917 >                = e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
918              assertEquals(1, futures.size());
919              try {
920                  futures.get(0).get();

Diff Legend

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