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.41 by jsr166, Sun Feb 22 04:34:44 2015 UTC vs.
Revision 1.55 by jsr166, Thu Sep 5 21:37:25 2019 UTC

# Line 8 | Line 8
8  
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10   import static java.util.concurrent.TimeUnit.NANOSECONDS;
11 – import static java.util.concurrent.TimeUnit.SECONDS;
11  
12   import java.util.ArrayList;
13   import java.util.List;
# Line 30 | Line 29 | import junit.framework.TestSuite;
29   public class FutureTaskTest extends JSR166TestCase {
30  
31      public static void main(String[] args) {
32 <        junit.textui.TestRunner.run(suite());
32 >        main(suite(), args);
33      }
34      public static Test suite() {
35          return new TestSuite(FutureTaskTest.class);
# Line 61 | Line 60 | public class FutureTaskTest extends JSR1
60              pf.run();
61              pf.runAndReset();
62              assertEquals(savedRunCount, pf.runCount());
63 +            Object r2 = null;
64              try {
65 <                assertSame(r, f.get());
65 >                r2 = f.get();
66              } catch (CancellationException t) {
67                  assertSame(exInfo, CancellationException.class);
68              } catch (ExecutionException t) {
# Line 70 | Line 70 | public class FutureTaskTest extends JSR1
70              } catch (Throwable t) {
71                  threadUnexpectedException(t);
72              }
73 +            if (exInfo == null)
74 +                assertSame(r, r2);
75              assertTrue(f.isDone());
76          }
77      }
# Line 102 | Line 104 | public class FutureTaskTest extends JSR1
104          }
105      }
106  
107 <    <T> void checkCompletedNormally(Future<T> f, T expected) {
107 >    <T> void checkCompletedNormally(Future<T> f, T expectedValue) {
108          checkIsDone(f);
109          assertFalse(f.isCancelled());
110  
111 +        T v1 = null, v2 = null;
112          try {
113 <            assertSame(expected, f.get());
114 <        } catch (Throwable fail) { threadUnexpectedException(fail); }
112 <        try {
113 <            assertSame(expected, f.get(5L, SECONDS));
113 >            v1 = f.get();
114 >            v2 = f.get(randomTimeout(), randomTimeUnit());
115          } catch (Throwable fail) { threadUnexpectedException(fail); }
116 +        assertSame(expectedValue, v1);
117 +        assertSame(expectedValue, v2);
118      }
119  
120      void checkCancelled(Future<?> f) {
# Line 125 | Line 128 | public class FutureTaskTest extends JSR1
128          } catch (Throwable fail) { threadUnexpectedException(fail); }
129  
130          try {
131 <            f.get(5L, SECONDS);
131 >            f.get(randomTimeout(), randomTimeUnit());
132              shouldThrow();
133          } catch (CancellationException success) {
134          } catch (Throwable fail) { threadUnexpectedException(fail); }
# Line 151 | Line 154 | public class FutureTaskTest extends JSR1
154          } catch (Throwable fail) { threadUnexpectedException(fail); }
155  
156          try {
157 <            f.get(5L, SECONDS);
157 >            f.get(randomTimeout(), randomTimeUnit());
158              shouldThrow();
159          } catch (ExecutionException success) {
160              assertSame(t, success.getCause());
# Line 267 | Line 270 | public class FutureTaskTest extends JSR1
270          for (int i = 0; i < 3; i++) {
271              assertTrue(task.runAndReset());
272              checkNotDone(task);
273 <            assertEquals(i+1, task.runCount());
274 <            assertEquals(i+1, task.runAndResetCount());
273 >            assertEquals(i + 1, task.runCount());
274 >            assertEquals(i + 1, task.runAndResetCount());
275              assertEquals(0, task.setCount());
276              assertEquals(0, task.setExceptionCount());
277          }
# Line 284 | Line 287 | public class FutureTaskTest extends JSR1
287              for (int i = 0; i < 3; i++) {
288                  assertFalse(task.runAndReset());
289                  assertEquals(0, task.runCount());
290 <                assertEquals(i+1, task.runAndResetCount());
290 >                assertEquals(i + 1, task.runAndResetCount());
291                  assertEquals(0, task.setCount());
292                  assertEquals(0, task.setExceptionCount());
293              }
# Line 417 | Line 420 | public class FutureTaskTest extends JSR1
420                          delay(LONG_DELAY_MS);
421                          shouldThrow();
422                      } catch (InterruptedException success) {}
423 +                    assertFalse(Thread.interrupted());
424                  }});
425  
426          Thread t = newStartedThread(task);
# Line 460 | Line 464 | public class FutureTaskTest extends JSR1
464          try {
465              task.cancel(true);
466              shouldThrow();
467 <        } catch (SecurityException expected) {}
467 >        } catch (SecurityException success) {}
468  
469          // We failed to deliver the interrupt, but the world retains
470          // its sanity, as if we had done task.cancel(false)
# Line 486 | Line 490 | public class FutureTaskTest extends JSR1
490          final PublicFutureTask task =
491              new PublicFutureTask(new Runnable() {
492                  public void run() {
493 +                    pleaseCancel.countDown();
494                      try {
490 –                        pleaseCancel.countDown();
495                          delay(LONG_DELAY_MS);
496                          threadShouldThrow();
497                      } catch (InterruptedException success) {
# Line 752 | Line 756 | public class FutureTaskTest extends JSR1
756              public void realRun() throws Exception {
757                  Thread.currentThread().interrupt();
758                  try {
759 <                    task.get(2*LONG_DELAY_MS, MILLISECONDS);
759 >                    task.get(randomTimeout(), randomTimeUnit());
760                      shouldThrow();
761                  } catch (InterruptedException success) {}
762                  assertFalse(Thread.interrupted());
763  
764                  pleaseInterrupt.countDown();
765                  try {
766 <                    task.get(2*LONG_DELAY_MS, MILLISECONDS);
766 >                    task.get(LONGER_DELAY_MS, MILLISECONDS);
767                      shouldThrow();
768                  } catch (InterruptedException success) {}
769                  assertFalse(Thread.interrupted());
770              }});
771  
772          await(pleaseInterrupt);
773 +        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
774          t.interrupt();
775          awaitTermination(t);
776          checkNotDone(task);
# Line 836 | Line 841 | public class FutureTaskTest extends JSR1
841          }
842      }
843  
844 +    /**
845 +     * toString indicates current completion state
846 +     */
847 +    public void testToString_incomplete() {
848 +        FutureTask<String> f = new FutureTask<>(() -> "");
849 +        assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));
850 +        if (testImplementationDetails)
851 +            assertTrue(f.toString().startsWith(
852 +                               identityString(f) + "[Not completed, task ="));
853 +    }
854 +
855 +    public void testToString_normal() {
856 +        FutureTask<String> f = new FutureTask<>(() -> "");
857 +        f.run();
858 +        assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));
859 +        if (testImplementationDetails)
860 +            assertEquals(identityString(f) + "[Completed normally]",
861 +                         f.toString());
862 +    }
863 +
864 +    public void testToString_exception() {
865 +        FutureTask<String> f = new FutureTask<>(
866 +                () -> { throw new ArithmeticException(); });
867 +        f.run();
868 +        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
869 +        if (testImplementationDetails)
870 +            assertTrue(f.toString().startsWith(
871 +                               identityString(f) + "[Completed exceptionally: "));
872 +    }
873 +
874 +    public void testToString_cancelled() {
875 +        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
876 +            FutureTask<String> f = new FutureTask<>(() -> "");
877 +            assertTrue(f.cancel(mayInterruptIfRunning));
878 +            assertTrue(f.toString().matches(".*\\[.*Cancelled.*\\]"));
879 +            if (testImplementationDetails)
880 +                assertEquals(identityString(f) + "[Cancelled]",
881 +                             f.toString());
882 +        }
883 +    }
884 +
885   }

Diff Legend

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