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.47 by jsr166, Wed Aug 16 17:18:34 2017 UTC vs.
Revision 1.57 by dl, Tue Jan 26 13:33:06 2021 UTC

# Line 60 | 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 69 | 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 87 | Line 90 | public class FutureTaskTest extends JSR1
90      void checkIsRunning(Future<?> f) {
91          checkNotDone(f);
92          if (f instanceof FutureTask) {
93 <            FutureTask ft = (FutureTask<?>) f;
93 >            FutureTask<?> ft = (FutureTask<?>) f;
94              // Check that run methods do nothing
95              ft.run();
96              if (f instanceof PublicFutureTask) {
# Line 101 | 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 <            assertSame(expected, f.get(randomTimeout(), randomTimeUnit()));
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 158 | Line 164 | public class FutureTaskTest extends JSR1
164      /**
165       * Subclass to expose protected methods
166       */
167 <    static class PublicFutureTask extends FutureTask {
167 >    static class PublicFutureTask extends FutureTask<Object> {
168          private final AtomicInteger runCount;
169          private final AtomicInteger doneCount = new AtomicInteger(0);
170          private final AtomicInteger runAndResetCount = new AtomicInteger(0);
# Line 185 | Line 191 | public class FutureTaskTest extends JSR1
191                  }}, result);
192              this.runCount = runCount;
193          }
194 <        PublicFutureTask(Callable callable) {
194 >        PublicFutureTask(Callable<?> callable) {
195              this(callable, new AtomicInteger(0));
196          }
197 <        private PublicFutureTask(final Callable callable,
197 >        private PublicFutureTask(final Callable<?> callable,
198                                   final AtomicInteger runCount) {
199 <            super(new Callable() {
199 >            super(new Callable<Object>() {
200                  public Object call() throws Exception {
201                      runCount.getAndIncrement();
202                      return callable.call();
# Line 229 | Line 235 | public class FutureTaskTest extends JSR1
235       */
236      public void testConstructor() {
237          try {
238 <            new FutureTask(null);
238 >            new FutureTask<Void>(null);
239              shouldThrow();
240          } catch (NullPointerException success) {}
241      }
# Line 239 | Line 245 | public class FutureTaskTest extends JSR1
245       */
246      public void testConstructor2() {
247          try {
248 <            new FutureTask(null, Boolean.TRUE);
248 >            new FutureTask<Boolean>(null, Boolean.TRUE);
249              shouldThrow();
250          } catch (NullPointerException success) {}
251      }
# Line 458 | 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 671 | Line 677 | public class FutureTaskTest extends JSR1
677       */
678      public void testGet_ExecutionException() throws InterruptedException {
679          final ArithmeticException e = new ArithmeticException();
680 <        final PublicFutureTask task = new PublicFutureTask(new Callable() {
680 >        final PublicFutureTask task = new PublicFutureTask(new Callable<Object>() {
681              public Object call() {
682                  throw e;
683              }});
# Line 695 | Line 701 | public class FutureTaskTest extends JSR1
701       */
702      public void testTimedGet_ExecutionException2() throws Exception {
703          final ArithmeticException e = new ArithmeticException();
704 <        final PublicFutureTask task = new PublicFutureTask(new Callable() {
704 >        final PublicFutureTask task = new PublicFutureTask(new Callable<Object>() {
705              public Object call() {
706                  throw e;
707              }});
# Line 714 | Line 720 | public class FutureTaskTest extends JSR1
720      /**
721       * get is interruptible
722       */
723 <    public void testGet_interruptible() {
723 >    public void testGet_Interruptible() {
724          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
725 <        final FutureTask task = new FutureTask(new NoOpCallable());
725 >        final FutureTask<Object> task = new FutureTask<Object>(new NoOpCallable());
726          Thread t = newStartedThread(new CheckedRunnable() {
727              public void realRun() throws Exception {
728                  Thread.currentThread().interrupt();
# Line 743 | Line 749 | public class FutureTaskTest extends JSR1
749      /**
750       * timed get is interruptible
751       */
752 <    public void testTimedGet_interruptible() {
752 >    public void testTimedGet_Interruptible() {
753          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
754 <        final FutureTask task = new FutureTask(new NoOpCallable());
754 >        final FutureTask<Object> task = new FutureTask<Object>(new NoOpCallable());
755          Thread t = newStartedThread(new CheckedRunnable() {
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 773 | Line 780 | public class FutureTaskTest extends JSR1
780       * A timed out timed get throws TimeoutException
781       */
782      public void testGet_TimeoutException() throws Exception {
783 <        FutureTask task = new FutureTask(new NoOpCallable());
783 >        FutureTask<Object> task = new FutureTask<Object>(new NoOpCallable());
784          long startTime = System.nanoTime();
785          try {
786              task.get(timeoutMillis(), MILLISECONDS);
# Line 787 | Line 794 | public class FutureTaskTest extends JSR1
794       * timed get with null TimeUnit throws NullPointerException
795       */
796      public void testGet_NullTimeUnit() throws Exception {
797 <        FutureTask task = new FutureTask(new NoOpCallable());
797 >        FutureTask<Object> task = new FutureTask<Object>(new NoOpCallable());
798          long[] timeouts = { Long.MIN_VALUE, 0L, Long.MAX_VALUE };
799  
800          for (long timeout : timeouts) {
# Line 838 | Line 845 | public class FutureTaskTest extends JSR1
845       * toString indicates current completion state
846       */
847      public void testToString_incomplete() {
848 <        FutureTask<String> f = new FutureTask<String>(() -> "");
848 >        FutureTask<String> f = new FutureTask<>(() -> "");
849          assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));
850          if (testImplementationDetails)
851              assertTrue(f.toString().startsWith(
# Line 846 | Line 853 | public class FutureTaskTest extends JSR1
853      }
854  
855      public void testToString_normal() {
856 <        FutureTask<String> f = new FutureTask<String>(() -> "");
856 >        FutureTask<String> f = new FutureTask<>(() -> "");
857          f.run();
858          assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));
859          if (testImplementationDetails)
# Line 855 | Line 862 | public class FutureTaskTest extends JSR1
862      }
863  
864      public void testToString_exception() {
865 <        FutureTask<String> f = new FutureTask<String>(
865 >        FutureTask<String> f = new FutureTask<>(
866                  () -> { throw new ArithmeticException(); });
867          f.run();
868          assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
# Line 866 | Line 873 | public class FutureTaskTest extends JSR1
873  
874      public void testToString_cancelled() {
875          for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
876 <            FutureTask<String> f = new FutureTask<String>(() -> "");
876 >            FutureTask<String> f = new FutureTask<>(() -> "");
877              assertTrue(f.cancel(mayInterruptIfRunning));
878              assertTrue(f.toString().matches(".*\\[.*Cancelled.*\\]"));
879              if (testImplementationDetails)

Diff Legend

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