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.200 by jsr166, Thu Sep 20 20:17:13 2018 UTC vs.
Revision 1.211 by jsr166, Mon Sep 24 14:45:19 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 4839 | Line 4907 | public class CompletableFutureTest exten
4907      }}
4908  
4909      /**
4910 <     * defult exceptionallyCompose result completes normally after normal
4910 >     * default exceptionallyCompose result completes normally after normal
4911       * completion of source
4912       */
4913      public void testDefaultExceptionallyCompose_normalCompletion() {
# Line 4906 | Line 4974 | public class CompletableFutureTest exten
4974      }}
4975  
4976      /**
4977 <     * defult exceptionallyComposeAsync result completes normally after normal
4977 >     * default exceptionallyComposeAsync result completes normally after normal
4978       * completion of source
4979       */
4980      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
# Line 4974 | Line 5042 | public class CompletableFutureTest exten
5042  
5043  
5044      /**
5045 <     * defult exceptionallyComposeAsync result completes normally after normal
5045 >     * default exceptionallyComposeAsync result completes normally after normal
5046       * completion of source
5047       */
5048      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
# Line 4987 | Line 5055 | public class CompletableFutureTest exten
5055          final DelegatedCompletionStage<Integer> d =
5056              new DelegatedCompletionStage<Integer>(f);
5057          if (!createIncomplete) assertTrue(f.complete(v1));
5058 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5058 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5059          if (createIncomplete) assertTrue(f.complete(v1));
5060  
5061          checkCompletedNormally(f, v1);
# Line 5009 | Line 5077 | public class CompletableFutureTest exten
5077          final DelegatedCompletionStage<Integer> d =
5078              new DelegatedCompletionStage<Integer>(f);
5079          if (!createIncomplete) f.completeExceptionally(ex);
5080 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5080 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5081          if (createIncomplete) f.completeExceptionally(ex);
5082  
5083          checkCompletedExceptionally(f, ex);
# Line 5032 | Line 5100 | public class CompletableFutureTest exten
5100          final DelegatedCompletionStage<Integer> d =
5101              new DelegatedCompletionStage<Integer>(f);
5102          if (!createIncomplete) f.completeExceptionally(ex);
5103 <        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5103 >        final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5104          if (createIncomplete) f.completeExceptionally(ex);
5105  
5106          checkCompletedExceptionally(f, ex);

Diff Legend

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