ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/FutureTaskTest.java
(Generate patch)

Comparing jsr166/src/test/tck/FutureTaskTest.java (file contents):
Revision 1.29 by jsr166, Mon Jun 20 04:31:59 2011 UTC vs.
Revision 1.43 by jsr166, Sat Apr 25 04:55:30 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 > import static java.util.concurrent.TimeUnit.NANOSECONDS;
11 > import static java.util.concurrent.TimeUnit.SECONDS;
12 >
13 > import java.util.ArrayList;
14 > import java.util.List;
15 > import java.util.NoSuchElementException;
16   import java.util.concurrent.Callable;
17   import java.util.concurrent.CancellationException;
18   import java.util.concurrent.CountDownLatch;
19   import java.util.concurrent.ExecutionException;
20 + import java.util.concurrent.Executors;
21 + import java.util.concurrent.ExecutorService;
22   import java.util.concurrent.Future;
23   import java.util.concurrent.FutureTask;
24   import java.util.concurrent.TimeoutException;
25   import java.util.concurrent.atomic.AtomicInteger;
26 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
27 < import static java.util.concurrent.TimeUnit.SECONDS;
28 < import java.util.*;
26 >
27 > import junit.framework.Test;
28 > import junit.framework.TestSuite;
29  
30   public class FutureTaskTest extends JSR166TestCase {
31  
32      public static void main(String[] args) {
33 <        junit.textui.TestRunner.run(suite());
33 >        main(suite(), args);
34      }
35      public static Test suite() {
36          return new TestSuite(FutureTaskTest.class);
# Line 37 | Line 45 | public class FutureTaskTest extends JSR1
45              assertEquals(1, pf.doneCount());
46              assertFalse(pf.runAndReset());
47              assertEquals(1, pf.doneCount());
48 +            Object r = null; Object exInfo = null;
49 +            try {
50 +                r = f.get();
51 +            } catch (CancellationException t) {
52 +                exInfo = CancellationException.class;
53 +            } catch (ExecutionException t) {
54 +                exInfo = t.getCause();
55 +            } catch (Throwable t) {
56 +                threadUnexpectedException(t);
57 +            }
58  
59              // Check that run and runAndReset have no effect.
60              int savedRunCount = pf.runCount();
43 –            int savedSetCount = pf.setCount();
44 –            int savedSetExceptionCount = pf.setExceptionCount();
61              pf.run();
62              pf.runAndReset();
63              assertEquals(savedRunCount, pf.runCount());
64 <            assertEquals(savedSetCount, pf.setCount());
65 <            assertEquals(savedSetExceptionCount, pf.setExceptionCount());
64 >            try {
65 >                assertSame(r, f.get());
66 >            } catch (CancellationException t) {
67 >                assertSame(exInfo, CancellationException.class);
68 >            } catch (ExecutionException t) {
69 >                assertSame(exInfo, t.getCause());
70 >            } catch (Throwable t) {
71 >                threadUnexpectedException(t);
72 >            }
73              assertTrue(f.isDone());
74          }
75      }
# Line 68 | Line 91 | public class FutureTaskTest extends JSR1
91              FutureTask ft = (FutureTask<?>) f;
92              // Check that run methods do nothing
93              ft.run();
94 <            if (f instanceof PublicFutureTask)
95 <                assertFalse(((PublicFutureTask) f).runAndReset());
94 >            if (f instanceof PublicFutureTask) {
95 >                PublicFutureTask pf = (PublicFutureTask) f;
96 >                int savedRunCount = pf.runCount();
97 >                pf.run();
98 >                assertFalse(pf.runAndReset());
99 >                assertEquals(savedRunCount, pf.runCount());
100 >            }
101              checkNotDone(f);
102          }
103      }
# Line 107 | Line 135 | public class FutureTaskTest extends JSR1
135          pf.set(new Object());
136          pf.setException(new Error());
137          for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
138 <            pf.cancel(true);
138 >            pf.cancel(mayInterruptIfRunning);
139          }
140      }
141  
# Line 154 | Line 182 | public class FutureTaskTest extends JSR1
182          private PublicFutureTask(final Runnable runnable, Object result,
183                                   final AtomicInteger runCount) {
184              super(new Runnable() {
185 <                    public void run() {
186 <                        runCount.getAndIncrement();
187 <                        runnable.run();
188 <                    }}, result);
185 >                public void run() {
186 >                    runCount.getAndIncrement();
187 >                    runnable.run();
188 >                }}, result);
189              this.runCount = runCount;
190          }
191          PublicFutureTask(Callable callable) {
# Line 172 | Line 200 | public class FutureTaskTest extends JSR1
200                  }});
201              this.runCount = runCount;
202          }
203 <        public void done() {
203 >        @Override public void done() {
204              assertTrue(isDone());
205              doneCount.incrementAndGet();
206              super.done();
207          }
208 <        public boolean runAndReset() {
208 >        @Override public boolean runAndReset() {
209              runAndResetCount.incrementAndGet();
210              return super.runAndReset();
211          }
212 <        public void set(Object x) {
212 >        @Override public void set(Object x) {
213              setCount.incrementAndGet();
214              super.set(x);
215          }
216 <        public void setException(Throwable t) {
216 >        @Override public void setException(Throwable t) {
217              setExceptionCount.incrementAndGet();
218              super.setException(t);
219          }
# Line 319 | Line 347 | public class FutureTaskTest extends JSR1
347          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
348          assertTrue(task.cancel(false));
349          task.run();
350 +        assertEquals(0, task.runCount());
351          assertEquals(0, task.setCount());
352          assertEquals(0, task.setExceptionCount());
353 +        assertTrue(task.isCancelled());
354 +        assertTrue(task.isDone());
355          tryToConfuseDoneTask(task);
325 –        checkCancelled(task);
356          assertEquals(0, task.runCount());
357 +        checkCancelled(task);
358      }
359  
360      /**
# Line 333 | Line 364 | public class FutureTaskTest extends JSR1
364          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
365          assertTrue(task.cancel(true));
366          task.run();
367 +        assertEquals(0, task.runCount());
368          assertEquals(0, task.setCount());
369          assertEquals(0, task.setExceptionCount());
370 +        assertTrue(task.isCancelled());
371 +        assertTrue(task.isDone());
372          tryToConfuseDoneTask(task);
339 –        checkCancelled(task);
373          assertEquals(0, task.runCount());
374 +        checkCancelled(task);
375      }
376  
377      /**
# Line 347 | Line 381 | public class FutureTaskTest extends JSR1
381          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
382          task.run();
383          assertFalse(task.cancel(false));
384 +        assertEquals(1, task.runCount());
385          assertEquals(1, task.setCount());
386          assertEquals(0, task.setExceptionCount());
387          tryToConfuseDoneTask(task);
# Line 361 | Line 396 | public class FutureTaskTest extends JSR1
396          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
397          task.run();
398          assertFalse(task.cancel(true));
399 +        assertEquals(1, task.runCount());
400          assertEquals(1, task.setCount());
401          assertEquals(0, task.setExceptionCount());
402          tryToConfuseDoneTask(task);
# Line 387 | Line 423 | public class FutureTaskTest extends JSR1
423          await(pleaseCancel);
424          assertTrue(task.cancel(true));
425          assertTrue(task.isCancelled());
426 +        assertTrue(task.isDone());
427          awaitTermination(t);
428          assertEquals(1, task.runCount());
429          assertEquals(1, task.setCount());
# Line 396 | Line 433 | public class FutureTaskTest extends JSR1
433      }
434  
435      /**
436 +     * cancel(true) tries to interrupt a running task, but
437 +     * Thread.interrupt throws (simulating a restrictive security
438 +     * manager)
439 +     */
440 +    public void testCancelInterrupt_ThrowsSecurityException() {
441 +        final CountDownLatch pleaseCancel = new CountDownLatch(1);
442 +        final CountDownLatch cancelled = new CountDownLatch(1);
443 +        final PublicFutureTask task =
444 +            new PublicFutureTask(new CheckedRunnable() {
445 +                public void realRun() {
446 +                    pleaseCancel.countDown();
447 +                    await(cancelled);
448 +                    assertFalse(Thread.interrupted());
449 +                }});
450 +
451 +        final Thread t = new Thread(task) {
452 +            // Simulate a restrictive security manager.
453 +            @Override public void interrupt() {
454 +                throw new SecurityException();
455 +            }};
456 +        t.setDaemon(true);
457 +        t.start();
458 +
459 +        await(pleaseCancel);
460 +        try {
461 +            task.cancel(true);
462 +            shouldThrow();
463 +        } catch (SecurityException expected) {}
464 +
465 +        // We failed to deliver the interrupt, but the world retains
466 +        // its sanity, as if we had done task.cancel(false)
467 +        assertTrue(task.isCancelled());
468 +        assertTrue(task.isDone());
469 +        assertEquals(1, task.runCount());
470 +        assertEquals(1, task.doneCount());
471 +        assertEquals(0, task.setCount());
472 +        assertEquals(0, task.setExceptionCount());
473 +        cancelled.countDown();
474 +        awaitTermination(t);
475 +        assertEquals(1, task.setCount());
476 +        assertEquals(0, task.setExceptionCount());
477 +        tryToConfuseDoneTask(task);
478 +        checkCancelled(task);
479 +    }
480 +
481 +    /**
482       * cancel(true) interrupts a running task that subsequently throws
483       */
484      public void testCancelInterrupt_taskFails() {
# Line 403 | Line 486 | public class FutureTaskTest extends JSR1
486          final PublicFutureTask task =
487              new PublicFutureTask(new Runnable() {
488                  public void run() {
489 +                    pleaseCancel.countDown();
490                      try {
407 –                        pleaseCancel.countDown();
491                          delay(LONG_DELAY_MS);
492 <                    } finally { throw new RuntimeException(); }
492 >                        threadShouldThrow();
493 >                    } catch (InterruptedException success) {
494 >                    } catch (Throwable t) { threadUnexpectedException(t); }
495 >                    throw new RuntimeException();
496                  }});
497  
498          Thread t = newStartedThread(task);
# Line 531 | Line 617 | public class FutureTaskTest extends JSR1
617       * CancellationException
618       */
619      public void testTimedGet_Cancellation() {
620 <        for (final boolean mayInterruptIfRunning :
621 <                 new boolean[] { true, false }) {
622 <            final CountDownLatch pleaseCancel = new CountDownLatch(3);
623 <            final CountDownLatch cancelled = new CountDownLatch(1);
624 <            final PublicFutureTask task =
625 <                new PublicFutureTask(new CheckedCallable<Object>() {
626 <                    public Object realCall() throws InterruptedException {
627 <                        pleaseCancel.countDown();
628 <                        if (mayInterruptIfRunning) {
629 <                            try {
630 <                                delay(2*LONG_DELAY_MS);
631 <                            } catch (InterruptedException success) {}
632 <                        } else {
633 <                            await(cancelled);
634 <                        }
635 <                        return two;
636 <                    }});
620 >        testTimedGet_Cancellation(false);
621 >    }
622 >    public void testTimedGet_Cancellation_interrupt() {
623 >        testTimedGet_Cancellation(true);
624 >    }
625 >    public void testTimedGet_Cancellation(final boolean mayInterruptIfRunning) {
626 >        final CountDownLatch pleaseCancel = new CountDownLatch(3);
627 >        final CountDownLatch cancelled = new CountDownLatch(1);
628 >        final Callable<Object> callable =
629 >            new CheckedCallable<Object>() {
630 >            public Object realCall() throws InterruptedException {
631 >                pleaseCancel.countDown();
632 >                if (mayInterruptIfRunning) {
633 >                    try {
634 >                        delay(2*LONG_DELAY_MS);
635 >                    } catch (InterruptedException success) {}
636 >                } else {
637 >                    await(cancelled);
638 >                }
639 >                return two;
640 >            }};
641 >        final PublicFutureTask task = new PublicFutureTask(callable);
642  
643 <            Thread t1 = new ThreadShouldThrow(CancellationException.class) {
643 >        Thread t1 = new ThreadShouldThrow(CancellationException.class) {
644                  public void realRun() throws Exception {
645                      pleaseCancel.countDown();
646                      task.get();
647                  }};
648 <            Thread t2 = new ThreadShouldThrow(CancellationException.class) {
648 >        Thread t2 = new ThreadShouldThrow(CancellationException.class) {
649                  public void realRun() throws Exception {
650                      pleaseCancel.countDown();
651                      task.get(2*LONG_DELAY_MS, MILLISECONDS);
652                  }};
653 <            t1.start();
654 <            t2.start();
655 <            Thread t3 = newStartedThread(task);
656 <            await(pleaseCancel);
657 <            checkIsRunning(task);
658 <            task.cancel(mayInterruptIfRunning);
659 <            checkCancelled(task);
660 <            awaitTermination(t1);
661 <            awaitTermination(t2);
662 <            cancelled.countDown();
663 <            awaitTermination(t3);
664 <            assertEquals(1, task.runCount());
665 <            assertEquals(1, task.setCount());
666 <            assertEquals(0, task.setExceptionCount());
667 <            tryToConfuseDoneTask(task);
668 <            checkCancelled(task);
578 <        }
653 >        t1.start();
654 >        t2.start();
655 >        Thread t3 = newStartedThread(task);
656 >        await(pleaseCancel);
657 >        checkIsRunning(task);
658 >        task.cancel(mayInterruptIfRunning);
659 >        checkCancelled(task);
660 >        awaitTermination(t1);
661 >        awaitTermination(t2);
662 >        cancelled.countDown();
663 >        awaitTermination(t3);
664 >        assertEquals(1, task.runCount());
665 >        assertEquals(1, task.setCount());
666 >        assertEquals(0, task.setExceptionCount());
667 >        tryToConfuseDoneTask(task);
668 >        checkCancelled(task);
669      }
670  
671      /**
# Line 719 | Line 809 | public class FutureTaskTest extends JSR1
809          }
810      }
811  
812 +    /**
813 +     * timed get with most negative timeout works correctly (i.e. no
814 +     * underflow bug)
815 +     */
816 +    public void testGet_NegativeInfinityTimeout() throws Exception {
817 +        final ExecutorService pool = Executors.newFixedThreadPool(10);
818 +        final Runnable nop = new Runnable() { public void run() {}};
819 +        final FutureTask<Void> task = new FutureTask<>(nop, null);
820 +        final List<Future<?>> futures = new ArrayList<>();
821 +        Runnable r = new Runnable() { public void run() {
822 +            for (long timeout : new long[] { 0L, -1L, Long.MIN_VALUE }) {
823 +                try {
824 +                    task.get(timeout, NANOSECONDS);
825 +                    shouldThrow();
826 +                } catch (TimeoutException success) {
827 +                } catch (Throwable fail) {threadUnexpectedException(fail);}}}};
828 +        for (int i = 0; i < 10; i++)
829 +            futures.add(pool.submit(r));
830 +        try {
831 +            joinPool(pool);
832 +            for (Future<?> future : futures)
833 +                checkCompletedNormally(future, null);
834 +        } finally {
835 +            task.run();         // last resort to help terminate
836 +        }
837 +    }
838 +
839   }

Diff Legend

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