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.208 by jsr166, Sun Sep 23 15:29:31 2018 UTC vs.
Revision 1.216 by jsr166, Wed Nov 21 23:25:17 2018 UTC

# Line 3116 | Line 3116 | public class CompletableFutureTest exten
3116          case 0:
3117              assertTrue(f.complete(v1));
3118              assertTrue(g.completeExceptionally(ex));
3119 <            h = m.thenCompose(f, (x -> g));
3119 >            h = m.thenCompose(f, x -> g);
3120              break;
3121          case 1:
3122              assertTrue(f.complete(v1));
3123 <            h = m.thenCompose(f, (x -> g));
3123 >            h = m.thenCompose(f, x -> g);
3124              assertTrue(g.completeExceptionally(ex));
3125              break;
3126          case 2:
3127              assertTrue(g.completeExceptionally(ex));
3128              assertTrue(f.complete(v1));
3129 <            h = m.thenCompose(f, (x -> g));
3129 >            h = m.thenCompose(f, x -> g);
3130              break;
3131          case 3:
3132              assertTrue(g.completeExceptionally(ex));
3133 <            h = m.thenCompose(f, (x -> g));
3133 >            h = m.thenCompose(f, x -> g);
3134              assertTrue(f.complete(v1));
3135              break;
3136          case 4:
3137 <            h = m.thenCompose(f, (x -> g));
3137 >            h = m.thenCompose(f, x -> g);
3138              assertTrue(f.complete(v1));
3139              assertTrue(g.completeExceptionally(ex));
3140              break;
3141          case 5:
3142 <            h = m.thenCompose(f, (x -> g));
3142 >            h = m.thenCompose(f, x -> g);
3143              assertTrue(f.complete(v1));
3144              assertTrue(g.completeExceptionally(ex));
3145              break;
# Line 3167 | 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);
3170          checkCompletedNormally(f, v1);
3171          checkCompletedNormally(g, v1);
3172          r.assertNotInvoked();
# Line 3201 | Line 3199 | public class CompletableFutureTest exten
3199      public void testExceptionallyCompose_actionFailed() {
3200          for (ExecutionMode m : ExecutionMode.values())
3201          for (boolean createIncomplete : new boolean[] { true, false })
3204 –        for (Integer v1 : new Integer[] { 1, null })
3202      {
3203          final CFException ex = new CFException();
3204          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 3216 | Line 3213 | public class CompletableFutureTest exten
3213          r.assertInvoked();
3214      }}
3215  
3216 +    /**
3217 +     * exceptionallyCompose result completes exceptionally if the
3218 +     * result of the action does
3219 +     */
3220 +    public void testExceptionallyCompose_actionReturnsFailingFuture() {
3221 +        for (ExecutionMode m : ExecutionMode.values())
3222 +        for (int order = 0; order < 6; order++)
3223 +    {
3224 +        final CFException ex0 = new CFException();
3225 +        final CFException ex = new CFException();
3226 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
3227 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
3228 +        final CompletableFuture<Integer> h;
3229 +        // Test all permutations of orders
3230 +        switch (order) {
3231 +        case 0:
3232 +            assertTrue(f.completeExceptionally(ex0));
3233 +            assertTrue(g.completeExceptionally(ex));
3234 +            h = m.exceptionallyCompose(f, x -> g);
3235 +            break;
3236 +        case 1:
3237 +            assertTrue(f.completeExceptionally(ex0));
3238 +            h = m.exceptionallyCompose(f, x -> g);
3239 +            assertTrue(g.completeExceptionally(ex));
3240 +            break;
3241 +        case 2:
3242 +            assertTrue(g.completeExceptionally(ex));
3243 +            assertTrue(f.completeExceptionally(ex0));
3244 +            h = m.exceptionallyCompose(f, x -> g);
3245 +            break;
3246 +        case 3:
3247 +            assertTrue(g.completeExceptionally(ex));
3248 +            h = m.exceptionallyCompose(f, x -> g);
3249 +            assertTrue(f.completeExceptionally(ex0));
3250 +            break;
3251 +        case 4:
3252 +            h = m.exceptionallyCompose(f, x -> g);
3253 +            assertTrue(f.completeExceptionally(ex0));
3254 +            assertTrue(g.completeExceptionally(ex));
3255 +            break;
3256 +        case 5:
3257 +            h = m.exceptionallyCompose(f, x -> g);
3258 +            assertTrue(f.completeExceptionally(ex0));
3259 +            assertTrue(g.completeExceptionally(ex));
3260 +            break;
3261 +        default: throw new AssertionError();
3262 +        }
3263 +
3264 +        checkCompletedExceptionally(g, ex);
3265 +        checkCompletedWithWrappedException(h, ex);
3266 +        checkCompletedExceptionally(f, ex0);
3267 +    }}
3268  
3269      // other static methods
3270  
# Line 3596 | Line 3645 | public class CompletableFutureTest exten
3645          final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3646          final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3647  
3599 –        List<CompletableFuture<?>> futures = new ArrayList<>();
3600 –
3601 –        List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3602 –        srcs.add(complete);
3603 –        srcs.add(incomplete);
3604 –
3648          List<CompletableFuture<?>> fs = new ArrayList<>();
3649          fs.add(incomplete.thenRunAsync(() -> {}, e));
3650          fs.add(incomplete.thenAcceptAsync(z -> {}, e));
# Line 4856 | Line 4899 | public class CompletableFutureTest exten
4899      }}
4900  
4901      /**
4902 <     * default exceptionallyCompose result completes normally after normal
4903 <     * completion of source
4902 >     * default-implemented exceptionallyCompose result completes
4903 >     * normally after normal completion of source
4904       */
4905      public void testDefaultExceptionallyCompose_normalCompletion() {
4906          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4905 | Line 4948 | public class CompletableFutureTest exten
4948       */
4949      public void testDefaultExceptionallyCompose_actionFailed() {
4950          for (boolean createIncomplete : new boolean[] { true, false })
4908 –        for (Integer v1 : new Integer[] { 1, null })
4951      {
4952          final CFException ex = new CFException();
4953          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4923 | Line 4965 | public class CompletableFutureTest exten
4965      }}
4966  
4967      /**
4968 <     * default exceptionallyComposeAsync result completes normally after normal
4969 <     * completion of source
4968 >     * default-implemented exceptionallyComposeAsync result completes
4969 >     * normally after normal completion of source
4970       */
4971      public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4972          for (boolean createIncomplete : new boolean[] { true, false })
# Line 4972 | Line 5014 | public class CompletableFutureTest exten
5014       */
5015      public void testDefaultExceptionallyComposeAsync_actionFailed() {
5016          for (boolean createIncomplete : new boolean[] { true, false })
4975 –        for (Integer v1 : new Integer[] { 1, null })
5017      {
5018          final CFException ex = new CFException();
5019          final CompletableFuture<Integer> f = new CompletableFuture<>();
# Line 4989 | Line 5030 | public class CompletableFutureTest exten
5030          r.assertInvoked();
5031      }}
5032  
4992 –
5033      /**
5034 <     * default exceptionallyComposeAsync result completes normally after normal
5035 <     * completion of source
5034 >     * default-implemented exceptionallyComposeAsync result completes
5035 >     * normally after normal completion of source
5036       */
5037      public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5038          for (boolean createIncomplete : new boolean[] { true, false })
# Line 5040 | Line 5080 | public class CompletableFutureTest exten
5080       */
5081      public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5082          for (boolean createIncomplete : new boolean[] { true, false })
5043 –        for (Integer v1 : new Integer[] { 1, null })
5083      {
5084          final CFException ex = new CFException();
5085          final CompletableFuture<Integer> f = new CompletableFuture<>();

Diff Legend

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