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

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.199 by dl, Thu Sep 20 00:01:22 2018 UTC vs.
Revision 1.209 by jsr166, Sun Sep 23 17:02:24 2018 UTC

# Line 551 | Line 551 | public class CompletableFutureTest exten
551          public CompletableFuture<Integer> apply(Integer x) {
552              invoked();
553              value = x;
554 <            CompletableFuture<Integer> f = new CompletableFuture<>();
555 <            assertTrue(f.complete(inc(x)));
556 <            return f;
554 >            return CompletableFuture.completedFuture(inc(x));
555          }
556      }
557  
# Line 574 | Line 572 | public class CompletableFutureTest exten
572          ExceptionalCompletableFutureFunction(ExecutionMode m) { super(m); }
573          public CompletionStage<Integer> apply(Throwable x) {
574              invoked();
575 <            CompletableFuture<Integer> d = new CompletableFuture<Integer>();
578 <            d.complete(value);
579 <            return d;
575 >            return CompletableFuture.completedFuture(value);
576          }
577      }
578  
# Line 930 | Line 926 | public class CompletableFutureTest exten
926          for (boolean createIncomplete : new boolean[] { true, false })
927          for (Integer v1 : new Integer[] { 1, null })
928      {
933 –        final AtomicInteger a = new AtomicInteger(0);
929          final CompletableFuture<Integer> f = new CompletableFuture<>();
930          if (!createIncomplete) assertTrue(f.complete(v1));
931          final CompletableFuture<Integer> g = m.exceptionally
932              (f, (Throwable t) -> {
938 –                a.getAndIncrement();
933                  threadFail("should not be called");
934                  return null;            // unreached
935              });
# Line 943 | Line 937 | public class CompletableFutureTest exten
937  
938          checkCompletedNormally(g, v1);
939          checkCompletedNormally(f, v1);
946 –        assertEquals(0, a.get());
940      }}
941  
942      /**
# Line 3174 | Line 3167 | public class CompletableFutureTest exten
3167          final CompletableFuture<Integer> g = m.exceptionallyCompose(f, r);
3168          if (createIncomplete) assertTrue(f.complete(v1));
3169  
3170 +        if (!createIncomplete && testImplementationDetails)
3171 +            assertSame(f, g);   // an optimization
3172 +
3173          checkCompletedNormally(f, v1);
3174          checkCompletedNormally(g, v1);
3175          r.assertNotInvoked();
# Line 3221 | Line 3217 | public class CompletableFutureTest exten
3217          r.assertInvoked();
3218      }}
3219  
3220 +    /**
3221 +     * thenComposeExceptionally result completes exceptionally if the
3222 +     * result of the action does
3223 +     */
3224 +    public void testExceptionallyCompose_actionReturnsFailingFuture() {
3225 +        for (ExecutionMode m : ExecutionMode.values())
3226 +        for (int order = 0; order < 6; order++)
3227 +        for (Integer v1 : new Integer[] { 1, null })
3228 +    {
3229 +        final CFException ex0 = new CFException();
3230 +        final CFException ex = new CFException();
3231 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
3232 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
3233 +        final CompletableFuture<Integer> h;
3234 +        // Test all permutations of orders
3235 +        switch (order) {
3236 +        case 0:
3237 +            assertTrue(f.completeExceptionally(ex0));
3238 +            assertTrue(g.completeExceptionally(ex));
3239 +            h = m.exceptionallyCompose(f, (x -> g));
3240 +            break;
3241 +        case 1:
3242 +            assertTrue(f.completeExceptionally(ex0));
3243 +            h = m.exceptionallyCompose(f, (x -> g));
3244 +            assertTrue(g.completeExceptionally(ex));
3245 +            break;
3246 +        case 2:
3247 +            assertTrue(g.completeExceptionally(ex));
3248 +            assertTrue(f.completeExceptionally(ex0));
3249 +            h = m.exceptionallyCompose(f, (x -> g));
3250 +            break;
3251 +        case 3:
3252 +            assertTrue(g.completeExceptionally(ex));
3253 +            h = m.exceptionallyCompose(f, (x -> g));
3254 +            assertTrue(f.completeExceptionally(ex0));
3255 +            break;
3256 +        case 4:
3257 +            h = m.exceptionallyCompose(f, (x -> g));
3258 +            assertTrue(f.completeExceptionally(ex0));
3259 +            assertTrue(g.completeExceptionally(ex));
3260 +            break;
3261 +        case 5:
3262 +            h = m.exceptionallyCompose(f, (x -> g));
3263 +            assertTrue(f.completeExceptionally(ex0));
3264 +            assertTrue(g.completeExceptionally(ex));
3265 +            break;
3266 +        default: throw new AssertionError();
3267 +        }
3268 +
3269 +        checkCompletedExceptionally(g, ex);
3270 +
3271 +        // TODO: should this be: checkCompletedWithWrappedException(h, ex);
3272 +        try {
3273 +            h.join();
3274 +            shouldThrow();
3275 +        } catch (Throwable t) {
3276 +            assertSame(ex, (t instanceof CompletionException) ? t.getCause() : t);
3277 +        }
3278 +
3279 +        checkCompletedExceptionally(f, ex0);
3280 +    }}
3281  
3282      // other static methods
3283  
# Line 4784 | Line 4841 | public class CompletableFutureTest exten
4841      }
4842  
4843      /**
4844 +     * default-implemented exceptionallyAsync action is not invoked when
4845 +     * source completes normally, and source result is propagated
4846 +     */
4847 +    public void testDefaultExceptionallyAsync_normalCompletion() {
4848 +        for (boolean createIncomplete : new boolean[] { true, false })
4849 +        for (Integer v1 : new Integer[] { 1, null })
4850 +    {
4851 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
4852 +        final DelegatedCompletionStage<Integer> d =
4853 +            new DelegatedCompletionStage<Integer>(f);
4854 +        if (!createIncomplete) assertTrue(f.complete(v1));
4855 +        final CompletionStage<Integer> g = d.exceptionallyAsync
4856 +            ((Throwable t) -> {
4857 +                threadFail("should not be called");
4858 +                return null;            // unreached
4859 +            });
4860 +        if (createIncomplete) assertTrue(f.complete(v1));
4861 +
4862 +        checkCompletedNormally(g.toCompletableFuture(), v1);
4863 +    }}
4864 +
4865 +    /**
4866       * default-implemented exceptionallyAsync action completes with
4867       * function value on source exception
4868       */
4869 <    public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4869 >    public void testDefaultExceptionallyAsync_exceptionalCompletion() {
4870          for (boolean createIncomplete : new boolean[] { true, false })
4871          for (Integer v1 : new Integer[] { 1, null })
4872      {
# Line 4814 | Line 4893 | public class CompletableFutureTest exten
4893       * throws an exception, it completes exceptionally with that
4894       * exception
4895       */
4896 <    public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4896 >    public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4897          for (boolean createIncomplete : new boolean[] { true, false })
4898      {
4899          final AtomicInteger a = new AtomicInteger(0);
# Line 4839 | Line 4918 | public class CompletableFutureTest exten
4918      }}
4919  
4920      /**
4921 <     * defult exceptionallyCompose result completes normally after normal
4921 >     * default exceptionallyCompose result completes normally after normal
4922       * completion of source
4923       */
4924      public void testDefaultExceptionallyCompose_normalCompletion() {
# Line 4906 | Line 4985 | public class CompletableFutureTest exten
4985      }}
4986  
4987      /**
4988 <     * defult exceptionallyComposeAsync result completes normally after normal
4988 >     * default exceptionallyComposeAsync result completes normally after normal
4989       * completion of source
4990       */
4991      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
# Line 4974 | Line 5053 | public class CompletableFutureTest exten
5053  
5054  
5055      /**
5056 <     * defult exceptionallyComposeAsync result completes normally after normal
5056 >     * default exceptionallyComposeAsync result completes normally after normal
5057       * completion of source
5058       */
5059      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
# Line 4987 | Line 5066 | public class CompletableFutureTest exten
5066          final DelegatedCompletionStage<Integer> d =
5067              new DelegatedCompletionStage<Integer>(f);
5068          if (!createIncomplete) assertTrue(f.complete(v1));
5069 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5069 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5070          if (createIncomplete) assertTrue(f.complete(v1));
5071  
5072          checkCompletedNormally(f, v1);
# Line 5009 | Line 5088 | public class CompletableFutureTest exten
5088          final DelegatedCompletionStage<Integer> d =
5089              new DelegatedCompletionStage<Integer>(f);
5090          if (!createIncomplete) f.completeExceptionally(ex);
5091 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5091 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5092          if (createIncomplete) f.completeExceptionally(ex);
5093  
5094          checkCompletedExceptionally(f, ex);
# Line 5032 | Line 5111 | public class CompletableFutureTest exten
5111          final DelegatedCompletionStage<Integer> d =
5112              new DelegatedCompletionStage<Integer>(f);
5113          if (!createIncomplete) f.completeExceptionally(ex);
5114 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5114 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5115          if (createIncomplete) f.completeExceptionally(ex);
5116  
5117          checkCompletedExceptionally(f, ex);
# Line 5041 | Line 5120 | public class CompletableFutureTest exten
5120      }}
5121  
5122   }
5044 –

Diff Legend

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