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.36 by jsr166, Sun Apr 21 06:26:43 2013 UTC vs.
Revision 1.40 by jsr166, Wed Dec 31 19:05:42 2014 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  
# 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 461 | Line 489 | public class FutureTaskTest extends JSR1
489                      try {
490                          pleaseCancel.countDown();
491                          delay(LONG_DELAY_MS);
492 <                        shouldThrow();
493 <                    } catch (Throwable t) {
494 <                        assertTrue(t instanceof InterruptedException);
467 <                    }
492 >                        threadShouldThrow();
493 >                    } catch (InterruptedException success) {
494 >                    } catch (Throwable t) { threadUnexpectedException(t); }
495                      throw new RuntimeException();
496                  }});
497  
# Line 782 | 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