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.201 by jsr166, Sat Sep 22 21:04:48 2018 UTC vs.
Revision 1.212 by jsr166, Mon Sep 24 17:04:26 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 3221 | Line 3214 | public class CompletableFutureTest exten
3214          r.assertInvoked();
3215      }}
3216  
3217 +    /**
3218 +     * exceptionallyCompose result completes exceptionally if the
3219 +     * result of the action does
3220 +     */
3221 +    public void testExceptionallyCompose_actionReturnsFailingFuture() {
3222 +        for (ExecutionMode m : ExecutionMode.values())
3223 +        for (int order = 0; order < 6; order++)
3224 +        for (Integer v1 : new Integer[] { 1, null })
3225 +    {
3226 +        final CFException ex0 = new CFException();
3227 +        final CFException ex = new CFException();
3228 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
3229 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
3230 +        final CompletableFuture<Integer> h;
3231 +        // Test all permutations of orders
3232 +        switch (order) {
3233 +        case 0:
3234 +            assertTrue(f.completeExceptionally(ex0));
3235 +            assertTrue(g.completeExceptionally(ex));
3236 +            h = m.exceptionallyCompose(f, (x -> g));
3237 +            break;
3238 +        case 1:
3239 +            assertTrue(f.completeExceptionally(ex0));
3240 +            h = m.exceptionallyCompose(f, (x -> g));
3241 +            assertTrue(g.completeExceptionally(ex));
3242 +            break;
3243 +        case 2:
3244 +            assertTrue(g.completeExceptionally(ex));
3245 +            assertTrue(f.completeExceptionally(ex0));
3246 +            h = m.exceptionallyCompose(f, (x -> g));
3247 +            break;
3248 +        case 3:
3249 +            assertTrue(g.completeExceptionally(ex));
3250 +            h = m.exceptionallyCompose(f, (x -> g));
3251 +            assertTrue(f.completeExceptionally(ex0));
3252 +            break;
3253 +        case 4:
3254 +            h = m.exceptionallyCompose(f, (x -> g));
3255 +            assertTrue(f.completeExceptionally(ex0));
3256 +            assertTrue(g.completeExceptionally(ex));
3257 +            break;
3258 +        case 5:
3259 +            h = m.exceptionallyCompose(f, (x -> g));
3260 +            assertTrue(f.completeExceptionally(ex0));
3261 +            assertTrue(g.completeExceptionally(ex));
3262 +            break;
3263 +        default: throw new AssertionError();
3264 +        }
3265 +
3266 +        checkCompletedExceptionally(g, ex);
3267 +        checkCompletedWithWrappedException(h, ex);
3268 +        checkCompletedExceptionally(f, ex0);
3269 +    }}
3270  
3271      // other static methods
3272  
# Line 4784 | Line 4830 | public class CompletableFutureTest exten
4830      }
4831  
4832      /**
4833 +     * default-implemented exceptionallyAsync action is not invoked when
4834 +     * source completes normally, and source result is propagated
4835 +     */
4836 +    public void testDefaultExceptionallyAsync_normalCompletion() {
4837 +        for (boolean createIncomplete : new boolean[] { true, false })
4838 +        for (Integer v1 : new Integer[] { 1, null })
4839 +    {
4840 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
4841 +        final DelegatedCompletionStage<Integer> d =
4842 +            new DelegatedCompletionStage<Integer>(f);
4843 +        if (!createIncomplete) assertTrue(f.complete(v1));
4844 +        final CompletionStage<Integer> g = d.exceptionallyAsync
4845 +            ((Throwable t) -> {
4846 +                threadFail("should not be called");
4847 +                return null;            // unreached
4848 +            });
4849 +        if (createIncomplete) assertTrue(f.complete(v1));
4850 +
4851 +        checkCompletedNormally(g.toCompletableFuture(), v1);
4852 +    }}
4853 +
4854 +    /**
4855       * default-implemented exceptionallyAsync action completes with
4856       * function value on source exception
4857       */
4858 <    public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4858 >    public void testDefaultExceptionallyAsync_exceptionalCompletion() {
4859          for (boolean createIncomplete : new boolean[] { true, false })
4860          for (Integer v1 : new Integer[] { 1, null })
4861      {
# Line 4814 | Line 4882 | public class CompletableFutureTest exten
4882       * throws an exception, it completes exceptionally with that
4883       * exception
4884       */
4885 <    public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4885 >    public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4886          for (boolean createIncomplete : new boolean[] { true, false })
4887      {
4888          final AtomicInteger a = new AtomicInteger(0);
# Line 4972 | Line 5040 | public class CompletableFutureTest exten
5040          r.assertInvoked();
5041      }}
5042  
4975 –
5043      /**
5044       * default exceptionallyComposeAsync result completes normally after normal
5045       * completion of source
# Line 4987 | Line 5054 | public class CompletableFutureTest exten
5054          final DelegatedCompletionStage<Integer> d =
5055              new DelegatedCompletionStage<Integer>(f);
5056          if (!createIncomplete) assertTrue(f.complete(v1));
5057 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5057 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5058          if (createIncomplete) assertTrue(f.complete(v1));
5059  
5060          checkCompletedNormally(f, v1);
# Line 5009 | Line 5076 | public class CompletableFutureTest exten
5076          final DelegatedCompletionStage<Integer> d =
5077              new DelegatedCompletionStage<Integer>(f);
5078          if (!createIncomplete) f.completeExceptionally(ex);
5079 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5079 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5080          if (createIncomplete) f.completeExceptionally(ex);
5081  
5082          checkCompletedExceptionally(f, ex);
# Line 5032 | Line 5099 | public class CompletableFutureTest exten
5099          final DelegatedCompletionStage<Integer> d =
5100              new DelegatedCompletionStage<Integer>(f);
5101          if (!createIncomplete) f.completeExceptionally(ex);
5102 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5102 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5103          if (createIncomplete) f.completeExceptionally(ex);
5104  
5105          checkCompletedExceptionally(f, ex);

Diff Legend

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