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.38 by jsr166, Wed Jun 19 05:54:45 2013 UTC vs.
Revision 1.45 by jsr166, Sun May 14 00:56:43 2017 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 127 | 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 259 | Line 267 | public class FutureTaskTest extends JSR1
267          for (int i = 0; i < 3; i++) {
268              assertTrue(task.runAndReset());
269              checkNotDone(task);
270 <            assertEquals(i+1, task.runCount());
271 <            assertEquals(i+1, task.runAndResetCount());
270 >            assertEquals(i + 1, task.runCount());
271 >            assertEquals(i + 1, task.runAndResetCount());
272              assertEquals(0, task.setCount());
273              assertEquals(0, task.setExceptionCount());
274          }
# Line 276 | Line 284 | public class FutureTaskTest extends JSR1
284              for (int i = 0; i < 3; i++) {
285                  assertFalse(task.runAndReset());
286                  assertEquals(0, task.runCount());
287 <                assertEquals(i+1, task.runAndResetCount());
287 >                assertEquals(i + 1, task.runAndResetCount());
288                  assertEquals(0, task.setCount());
289                  assertEquals(0, task.setExceptionCount());
290              }
# Line 409 | Line 417 | public class FutureTaskTest extends JSR1
417                          delay(LONG_DELAY_MS);
418                          shouldThrow();
419                      } catch (InterruptedException success) {}
420 +                    assertFalse(Thread.interrupted());
421                  }});
422  
423          Thread t = newStartedThread(task);
# Line 478 | Line 487 | public class FutureTaskTest extends JSR1
487          final PublicFutureTask task =
488              new PublicFutureTask(new Runnable() {
489                  public void run() {
490 +                    pleaseCancel.countDown();
491                      try {
482 –                        pleaseCancel.countDown();
492                          delay(LONG_DELAY_MS);
493                          threadShouldThrow();
494                      } catch (InterruptedException success) {
# Line 801 | Line 810 | public class FutureTaskTest extends JSR1
810          }
811      }
812  
813 +    /**
814 +     * timed get with most negative timeout works correctly (i.e. no
815 +     * underflow bug)
816 +     */
817 +    public void testGet_NegativeInfinityTimeout() throws Exception {
818 +        final ExecutorService pool = Executors.newFixedThreadPool(10);
819 +        final Runnable nop = new Runnable() { public void run() {}};
820 +        final FutureTask<Void> task = new FutureTask<>(nop, null);
821 +        final List<Future<?>> futures = new ArrayList<>();
822 +        Runnable r = new Runnable() { public void run() {
823 +            for (long timeout : new long[] { 0L, -1L, Long.MIN_VALUE }) {
824 +                try {
825 +                    task.get(timeout, NANOSECONDS);
826 +                    shouldThrow();
827 +                } catch (TimeoutException success) {
828 +                } catch (Throwable fail) {threadUnexpectedException(fail);}}}};
829 +        for (int i = 0; i < 10; i++)
830 +            futures.add(pool.submit(r));
831 +        try {
832 +            joinPool(pool);
833 +            for (Future<?> future : futures)
834 +                checkCompletedNormally(future, null);
835 +        } finally {
836 +            task.run();         // last resort to help terminate
837 +        }
838 +    }
839 +
840   }

Diff Legend

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