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.49 by jsr166, Mon Jun 2 19:20:51 2014 UTC vs.
Revision 1.57 by jsr166, Mon Jun 2 22:48:50 2014 UTC

# Line 284 | Line 284 | public class CompletableFutureTest exten
284      public void testGetNumberOfDependents() {
285          CompletableFuture<Integer> f = new CompletableFuture<>();
286          assertEquals(0, f.getNumberOfDependents());
287 <        CompletableFuture g = f.thenRun(new Noop());
287 >        CompletableFuture g = f.thenRun(new Noop(ExecutionMode.DEFAULT));
288          assertEquals(1, f.getNumberOfDependents());
289          assertEquals(0, g.getNumberOfDependents());
290 <        CompletableFuture h = f.thenRun(new Noop());
290 >        CompletableFuture h = f.thenRun(new Noop(ExecutionMode.DEFAULT));
291          assertEquals(2, f.getNumberOfDependents());
292          f.complete(1);
293          checkCompletedNormally(g, null);
# Line 349 | Line 349 | public class CompletableFutureTest exten
349          }
350      }
351      static final class IncFunction implements Function<Integer,Integer> {
352 +        final ExecutionMode m;
353          int invocationCount = 0;
354          Integer value;
355 +        IncFunction(ExecutionMode m) { this.m = m; }
356          public Integer apply(Integer x) {
357 +            m.checkExecutionMode();
358              invocationCount++;
359              return value = inc(x);
360          }
361      }
362      static final class SubtractAction implements BiConsumer<Integer, Integer> {
363 +        final ExecutionMode m;
364          int invocationCount = 0;
365          Integer value;
366          // Check this action was invoked exactly once when result is computed.
367 +        SubtractAction(ExecutionMode m) { this.m = m; }
368          public void accept(Integer x, Integer y) {
369 +            m.checkExecutionMode();
370              invocationCount++;
371              value = subtract(x, y);
372          }
373      }
374      static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
375 +        final ExecutionMode m;
376          int invocationCount = 0;
377          Integer value;
378          // Check this action was invoked exactly once when result is computed.
379 +        SubtractFunction(ExecutionMode m) { this.m = m; }
380          public Integer apply(Integer x, Integer y) {
381 +            m.checkExecutionMode();
382              invocationCount++;
383              return value = subtract(x, y);
384          }
385      }
386      static final class Noop implements Runnable {
387 +        final ExecutionMode m;
388          int invocationCount = 0;
389 +        Noop(ExecutionMode m) { this.m = m; }
390          public void run() {
391 +            m.checkExecutionMode();
392              invocationCount++;
393          }
394      }
395  
396      static final class FailingSupplier implements Supplier<Integer> {
397 +        final ExecutionMode m;
398          int invocationCount = 0;
399 +        FailingSupplier(ExecutionMode m) { this.m = m; }
400          public Integer get() {
401 +            m.checkExecutionMode();
402              invocationCount++;
403              throw new CFException();
404          }
405      }
406      static final class FailingConsumer implements Consumer<Integer> {
407 +        final ExecutionMode m;
408          int invocationCount = 0;
409 +        FailingConsumer(ExecutionMode m) { this.m = m; }
410          public void accept(Integer x) {
411 +            m.checkExecutionMode();
412              invocationCount++;
413              throw new CFException();
414          }
415      }
416      static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
417 +        final ExecutionMode m;
418          int invocationCount = 0;
419 +        FailingBiConsumer(ExecutionMode m) { this.m = m; }
420          public void accept(Integer x, Integer y) {
421 +            m.checkExecutionMode();
422              invocationCount++;
423              throw new CFException();
424          }
425      }
426      static final class FailingFunction implements Function<Integer, Integer> {
427 +        final ExecutionMode m;
428          int invocationCount = 0;
429 +        FailingFunction(ExecutionMode m) { this.m = m; }
430          public Integer apply(Integer x) {
431 +            m.checkExecutionMode();
432              invocationCount++;
433              throw new CFException();
434          }
435      }
436      static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
437 +        final ExecutionMode m;
438          int invocationCount = 0;
439 +        FailingBiFunction(ExecutionMode m) { this.m = m; }
440          public Integer apply(Integer x, Integer y) {
441 +            m.checkExecutionMode();
442              invocationCount++;
443              throw new CFException();
444          }
445      }
446 <    static final class FailingNoop implements Runnable {
446 >    static final class FailingRunnable implements Runnable {
447 >        final ExecutionMode m;
448          int invocationCount = 0;
449 +        FailingRunnable(ExecutionMode m) { this.m = m; }
450          public void run() {
451 +            m.checkExecutionMode();
452              invocationCount++;
453              throw new CFException();
454          }
# Line 426 | Line 456 | public class CompletableFutureTest exten
456  
457      static final class CompletableFutureInc
458          implements Function<Integer, CompletableFuture<Integer>> {
459 +        final ExecutionMode m;
460          int invocationCount = 0;
461 +        CompletableFutureInc(ExecutionMode m) { this.m = m; }
462          public CompletableFuture<Integer> apply(Integer x) {
463 +            m.checkExecutionMode();
464              invocationCount++;
465              CompletableFuture<Integer> f = new CompletableFuture<>();
466              f.complete(inc(x));
# Line 437 | Line 470 | public class CompletableFutureTest exten
470  
471      static final class FailingCompletableFutureFunction
472          implements Function<Integer, CompletableFuture<Integer>> {
473 +        final ExecutionMode m;
474          int invocationCount = 0;
475 +        FailingCompletableFutureFunction(ExecutionMode m) { this.m = m; }
476          public CompletableFuture<Integer> apply(Integer x) {
477 +            m.checkExecutionMode();
478              invocationCount++;
479              throw new CFException();
480          }
# Line 446 | Line 482 | public class CompletableFutureTest exten
482  
483      // Used for explicit executor tests
484      static final class ThreadExecutor implements Executor {
485 <        AtomicInteger count = new AtomicInteger(0);
485 >        final AtomicInteger count = new AtomicInteger(0);
486 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
487 >        static boolean startedCurrentThread() {
488 >            return Thread.currentThread().getThreadGroup() == tg;
489 >        }
490  
491          public void execute(Runnable r) {
492              count.getAndIncrement();
493 <            new Thread(r).start();
493 >            new Thread(tg, r).start();
494          }
495      }
496  
# Line 463 | Line 503 | public class CompletableFutureTest exten
503              public void checkExecutionMode() {
504                  assertNull(ForkJoinTask.getPool());
505              }
506 +            public CompletableFuture<Void> runAsync(Runnable a) {
507 +                throw new UnsupportedOperationException();
508 +            }
509              public <T> CompletableFuture<Void> thenRun
510                  (CompletableFuture<T> f, Runnable a) {
511                  return f.thenRun(a);
# Line 531 | Line 574 | public class CompletableFutureTest exten
574                  assertSame(ForkJoinPool.commonPool(),
575                             ForkJoinTask.getPool());
576              }
577 +            public CompletableFuture<Void> runAsync(Runnable a) {
578 +                return CompletableFuture.runAsync(a);
579 +            }
580              public <T> CompletableFuture<Void> thenRun
581                  (CompletableFuture<T> f, Runnable a) {
582                  return f.thenRunAsync(a);
# Line 596 | Line 642 | public class CompletableFutureTest exten
642  
643          EXECUTOR {
644              public void checkExecutionMode() {
645 <                //TODO
645 >                assertTrue(ThreadExecutor.startedCurrentThread());
646 >            }
647 >            public CompletableFuture<Void> runAsync(Runnable a) {
648 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
649              }
650              public <T> CompletableFuture<Void> thenRun
651                  (CompletableFuture<T> f, Runnable a) {
# Line 662 | Line 711 | public class CompletableFutureTest exten
711          };
712  
713          public abstract void checkExecutionMode();
714 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
715          public abstract <T> CompletableFuture<Void> thenRun
716              (CompletableFuture<T> f, Runnable a);
717          public abstract <T> CompletableFuture<Void> thenAccept
# Line 740 | Line 790 | public class CompletableFutureTest exten
790          if (!createIncomplete) f.completeExceptionally(ex);
791          final CompletableFuture<Integer> g = f.exceptionally
792              ((Throwable t) -> {
793 +                ExecutionMode.DEFAULT.checkExecutionMode();
794                  threadAssertSame(t, ex);
795                  a.getAndIncrement();
796                  return v1;
# Line 761 | Line 812 | public class CompletableFutureTest exten
812          if (!createIncomplete) f.completeExceptionally(ex1);
813          final CompletableFuture<Integer> g = f.exceptionally
814              ((Throwable t) -> {
815 +                ExecutionMode.DEFAULT.checkExecutionMode();
816                  threadAssertSame(t, ex1);
817                  a.getAndIncrement();
818                  throw ex2;
# Line 786 | Line 838 | public class CompletableFutureTest exten
838          final CompletableFuture<Integer> g = m.handle
839              (f,
840               (Integer x, Throwable t) -> {
841 +                m.checkExecutionMode();
842                  threadAssertSame(x, v1);
843                  threadAssertNull(t);
844                  a.getAndIncrement();
# Line 814 | Line 867 | public class CompletableFutureTest exten
867          final CompletableFuture<Integer> g = m.handle
868              (f,
869               (Integer x, Throwable t) -> {
870 +                m.checkExecutionMode();
871                  threadAssertNull(x);
872                  threadAssertSame(t, ex);
873                  a.getAndIncrement();
# Line 842 | Line 896 | public class CompletableFutureTest exten
896          final CompletableFuture<Integer> g = m.handle
897              (f,
898               (Integer x, Throwable t) -> {
899 +                m.checkExecutionMode();
900                  threadAssertNull(x);
901                  threadAssertTrue(t instanceof CancellationException);
902                  a.getAndIncrement();
# Line 869 | Line 924 | public class CompletableFutureTest exten
924          final CompletableFuture<Integer> g = m.handle
925              (f,
926               (Integer x, Throwable t) -> {
927 +                m.checkExecutionMode();
928                  threadAssertNull(x);
929                  threadAssertSame(ex1, t);
930                  a.getAndIncrement();
# Line 893 | Line 949 | public class CompletableFutureTest exten
949          final CompletableFuture<Integer> g = m.handle
950              (f,
951               (Integer x, Throwable t) -> {
952 +                m.checkExecutionMode();
953                  threadAssertSame(x, v1);
954                  threadAssertNull(t);
955                  a.getAndIncrement();
# Line 908 | Line 965 | public class CompletableFutureTest exten
965      /**
966       * runAsync completes after running Runnable
967       */
968 <    public void testRunAsync() {
969 <        Noop r = new Noop();
970 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
968 >    public void testRunAsync_normalCompletion() {
969 >        ExecutionMode[] executionModes = {
970 >            ExecutionMode.ASYNC,
971 >            ExecutionMode.EXECUTOR,
972 >        };
973 >        for (ExecutionMode m : executionModes)
974 >    {
975 >        final Noop r = new Noop(m);
976 >        final CompletableFuture<Void> f = m.runAsync(r);
977          assertNull(f.join());
915 –        assertEquals(1, r.invocationCount);
978          checkCompletedNormally(f, null);
917 –    }
918 –
919 –    /**
920 –     * runAsync with executor completes after running Runnable
921 –     */
922 –    public void testRunAsync2() {
923 –        Noop r = new Noop();
924 –        ThreadExecutor exec = new ThreadExecutor();
925 –        CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
926 –        assertNull(f.join());
979          assertEquals(1, r.invocationCount);
980 <        checkCompletedNormally(f, null);
929 <        assertEquals(1, exec.count.get());
930 <    }
980 >    }}
981  
982      /**
983       * failing runAsync completes exceptionally after running Runnable
984       */
985 <    public void testRunAsync3() {
986 <        FailingNoop r = new FailingNoop();
987 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
985 >    public void testRunAsync_exceptionalCompletion() {
986 >        ExecutionMode[] executionModes = {
987 >            ExecutionMode.ASYNC,
988 >            ExecutionMode.EXECUTOR,
989 >        };
990 >        for (ExecutionMode m : executionModes)
991 >    {
992 >        final FailingRunnable r = new FailingRunnable(m);
993 >        final CompletableFuture<Void> f = m.runAsync(r);
994          checkCompletedWithWrappedCFException(f);
995          assertEquals(1, r.invocationCount);
996 <    }
996 >    }}
997  
998      /**
999       * supplyAsync completes with result of supplier
# Line 963 | Line 1019 | public class CompletableFutureTest exten
1019       * Failing supplyAsync completes exceptionally
1020       */
1021      public void testSupplyAsync3() {
1022 <        FailingSupplier r = new FailingSupplier();
1022 >        FailingSupplier r = new FailingSupplier(ExecutionMode.ASYNC);
1023          CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1024          checkCompletedWithWrappedCFException(f);
1025          assertEquals(1, r.invocationCount);
# Line 980 | Line 1036 | public class CompletableFutureTest exten
1036          for (Integer v1 : new Integer[] { 1, null })
1037      {
1038          final CompletableFuture<Integer> f = new CompletableFuture<>();
1039 <        final Noop r = new Noop();
1039 >        final Noop r = new Noop(m);
1040          if (!createIncomplete) f.complete(v1);
1041          final CompletableFuture<Void> g = m.thenRun(f, r);
1042 <        if (createIncomplete) f.complete(v1);
1042 >        if (createIncomplete) {
1043 >            checkIncomplete(g);
1044 >            f.complete(v1);
1045 >        }
1046  
1047          checkCompletedNormally(g, null);
1048          checkCompletedNormally(f, v1);
# Line 1000 | Line 1059 | public class CompletableFutureTest exten
1059      {
1060          final CFException ex = new CFException();
1061          final CompletableFuture<Integer> f = new CompletableFuture<>();
1062 <        final Noop r = new Noop();
1062 >        final Noop r = new Noop(m);
1063          if (!createIncomplete) f.completeExceptionally(ex);
1064          final CompletableFuture<Void> g = m.thenRun(f, r);
1065 <        if (createIncomplete) f.completeExceptionally(ex);
1065 >        if (createIncomplete) {
1066 >            checkIncomplete(g);
1067 >            f.completeExceptionally(ex);
1068 >        }
1069  
1070          checkCompletedWithWrappedCFException(g, ex);
1071          checkCompletedWithWrappedCFException(f, ex);
# Line 1019 | Line 1081 | public class CompletableFutureTest exten
1081          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1082      {
1083          final CompletableFuture<Integer> f = new CompletableFuture<>();
1084 <        final Noop r = new Noop();
1084 >        final Noop r = new Noop(m);
1085          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1086 <        final CompletableFuture<Void> g = f.thenRun(r);
1087 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1086 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1087 >        if (createIncomplete) {
1088 >            checkIncomplete(g);
1089 >            assertTrue(f.cancel(mayInterruptIfRunning));
1090 >        }
1091  
1092          checkCompletedWithWrappedCancellationException(g);
1093          checkCancelled(f);
# Line 1038 | Line 1103 | public class CompletableFutureTest exten
1103          for (Integer v1 : new Integer[] { 1, null })
1104      {
1105          final CompletableFuture<Integer> f = new CompletableFuture<>();
1106 <        final FailingNoop r = new FailingNoop();
1106 >        final FailingRunnable r = new FailingRunnable(m);
1107          if (!createIncomplete) f.complete(v1);
1108 <        final CompletableFuture<Void> g = f.thenRun(r);
1109 <        if (createIncomplete) f.complete(v1);
1108 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1109 >        if (createIncomplete) {
1110 >            checkIncomplete(g);
1111 >            f.complete(v1);
1112 >        }
1113  
1114          checkCompletedWithWrappedCFException(g);
1115          checkCompletedNormally(f, v1);
# Line 1056 | Line 1124 | public class CompletableFutureTest exten
1124          for (Integer v1 : new Integer[] { 1, null })
1125      {
1126          final CompletableFuture<Integer> f = new CompletableFuture<>();
1127 <        final IncFunction r = new IncFunction();
1127 >        final IncFunction r = new IncFunction(m);
1128          if (!createIncomplete) f.complete(v1);
1129          final CompletableFuture<Integer> g = m.thenApply(f, r);
1130          if (createIncomplete) {
# Line 1079 | Line 1147 | public class CompletableFutureTest exten
1147      {
1148          final CFException ex = new CFException();
1149          final CompletableFuture<Integer> f = new CompletableFuture<>();
1150 <        final IncFunction r = new IncFunction();
1150 >        final IncFunction r = new IncFunction(m);
1151          if (!createIncomplete) f.completeExceptionally(ex);
1152          final CompletableFuture<Integer> g = m.thenApply(f, r);
1153 <        if (createIncomplete) f.completeExceptionally(ex);
1153 >        if (createIncomplete) {
1154 >            checkIncomplete(g);
1155 >            f.completeExceptionally(ex);
1156 >        }
1157  
1158          checkCompletedWithWrappedCFException(g, ex);
1159          checkCompletedWithWrappedCFException(f, ex);
# Line 1098 | Line 1169 | public class CompletableFutureTest exten
1169          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1170      {
1171          final CompletableFuture<Integer> f = new CompletableFuture<>();
1172 <        final IncFunction r = new IncFunction();
1172 >        final IncFunction r = new IncFunction(m);
1173          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1174 <        final CompletableFuture<Integer> g = f.thenApply(r);
1175 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1174 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1175 >        if (createIncomplete) {
1176 >            checkIncomplete(g);
1177 >            assertTrue(f.cancel(mayInterruptIfRunning));
1178 >        }
1179  
1180          checkCompletedWithWrappedCancellationException(g);
1181          checkCancelled(f);
# Line 1117 | Line 1191 | public class CompletableFutureTest exten
1191          for (Integer v1 : new Integer[] { 1, null })
1192      {
1193          final CompletableFuture<Integer> f = new CompletableFuture<>();
1194 <        final FailingFunction r = new FailingFunction();
1194 >        final FailingFunction r = new FailingFunction(m);
1195          if (!createIncomplete) f.complete(v1);
1196 <        final CompletableFuture<Integer> g = f.thenApply(r);
1197 <        if (createIncomplete) f.complete(v1);
1196 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1197 >        if (createIncomplete) {
1198 >            checkIncomplete(g);
1199 >            f.complete(v1);
1200 >        }
1201  
1202          checkCompletedWithWrappedCFException(g);
1203          checkCompletedNormally(f, v1);
# Line 1129 | Line 1206 | public class CompletableFutureTest exten
1206      /**
1207       * thenAccept result completes normally after normal completion of source
1208       */
1209 <    public void testThenAccept() {
1133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1134 <        IncAction r = new IncAction();
1135 <        CompletableFuture<Void> g = f.thenAccept(r);
1136 <        f.complete(one);
1137 <        checkCompletedNormally(g, null);
1138 <        assertEquals(r.value, (Integer) 2);
1139 <    }
1140 <
1141 <    /**
1142 <     * thenAccept result completes exceptionally after exceptional
1143 <     * completion of source
1144 <     */
1145 <    public void testThenAccept2() {
1146 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1147 <        IncAction r = new IncAction();
1148 <        CompletableFuture<Void> g = f.thenAccept(r);
1149 <        f.completeExceptionally(new CFException());
1150 <        checkCompletedWithWrappedCFException(g);
1151 <    }
1152 <
1153 <    /**
1154 <     * thenAccept result completes exceptionally if action does
1155 <     */
1156 <    public void testThenAccept3() {
1157 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1158 <        FailingConsumer r = new FailingConsumer();
1159 <        CompletableFuture<Void> g = f.thenAccept(r);
1160 <        f.complete(one);
1161 <        checkCompletedWithWrappedCFException(g);
1162 <        assertEquals(1, r.invocationCount);
1163 <    }
1164 <
1165 <    /**
1166 <     * thenAccept result completes exceptionally if source cancelled
1167 <     */
1168 <    public void testThenAccept4() {
1169 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1170 <        IncAction r = new IncAction();
1171 <        CompletableFuture<Void> g = f.thenAccept(r);
1172 <        assertTrue(f.cancel(true));
1173 <        checkCompletedWithWrappedCancellationException(g);
1174 <    }
1175 <
1176 <    /**
1177 <     * thenCombine result completes normally after normal completion
1178 <     * of sources
1179 <     */
1180 <    public void testThenCombine_normalCompletion1() {
1181 <        for (boolean createIncomplete : new boolean[] { true, false })
1182 <        for (boolean fFirst : new boolean[] { true, false })
1209 >    public void testThenAccept_normalCompletion() {
1210          for (ExecutionMode m : ExecutionMode.values())
1211 +        for (boolean createIncomplete : new boolean[] { true, false })
1212          for (Integer v1 : new Integer[] { 1, null })
1185 –        for (Integer v2 : new Integer[] { 2, null })
1213      {
1214          final CompletableFuture<Integer> f = new CompletableFuture<>();
1215 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1216 <        final SubtractFunction r = new SubtractFunction();
1217 <        CompletableFuture<Integer> h = null;
1218 <        if (createIncomplete) h = m.thenCombine(f, g, r);
1219 <
1193 <        if (fFirst)
1194 <            f.complete(v1);
1195 <        else
1196 <            g.complete(v2);
1197 <        if (createIncomplete) checkIncomplete(h);
1198 <        assertEquals(0, r.invocationCount);
1199 <        if (!fFirst)
1215 >        final IncAction r = new IncAction();
1216 >        if (!createIncomplete) f.complete(v1);
1217 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1218 >        if (createIncomplete) {
1219 >            checkIncomplete(g);
1220              f.complete(v1);
1221 <        else
1202 <            g.complete(v2);
1203 <        if (!createIncomplete) h = m.thenCombine(f, g, r);
1221 >        }
1222  
1223 <        checkCompletedNormally(h, subtract(v1, v2));
1223 >        checkCompletedNormally(g, null);
1224          checkCompletedNormally(f, v1);
1207 –        checkCompletedNormally(g, v2);
1225          assertEquals(1, r.invocationCount);
1226 +        assertEquals(inc(v1), r.value);
1227      }}
1228  
1229      /**
1230 <     * thenCombine result completes exceptionally after exceptional
1231 <     * completion of either source
1230 >     * thenAccept result completes exceptionally after exceptional
1231 >     * completion of source
1232       */
1233 <    public void testThenCombine_exceptionalCompletion1() {
1233 >    public void testThenAccept_exceptionalCompletion() {
1234          for (ExecutionMode m : ExecutionMode.values())
1235 <        for (Integer v1 : new Integer[] { 1, null })
1235 >        for (boolean createIncomplete : new boolean[] { true, false })
1236      {
1219 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1220 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1221 –        final SubtractFunction r = new SubtractFunction();
1222 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1237          final CFException ex = new CFException();
1224 –
1225 –        f.completeExceptionally(ex);
1226 –        checkIncomplete(h);
1227 –        g.complete(v1);
1228 –
1229 –        checkCompletedWithWrappedCFException(h, ex);
1230 –        checkCompletedWithWrappedCFException(f, ex);
1231 –        assertEquals(0, r.invocationCount);
1232 –        checkCompletedNormally(g, v1);
1233 –    }}
1234 –
1235 –    public void testThenCombine_exceptionalCompletion2() {
1236 –        for (ExecutionMode m : ExecutionMode.values())
1237 –        for (Integer v1 : new Integer[] { 1, null })
1238 –    {
1238          final CompletableFuture<Integer> f = new CompletableFuture<>();
1239 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1240 <        final SubtractFunction r = new SubtractFunction();
1241 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1242 <        final CFException ex = new CFException();
1243 <
1244 <        g.completeExceptionally(ex);
1245 <        checkIncomplete(h);
1247 <        f.complete(v1);
1239 >        final IncAction r = new IncAction();
1240 >        if (!createIncomplete) f.completeExceptionally(ex);
1241 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1242 >        if (createIncomplete) {
1243 >            checkIncomplete(g);
1244 >            f.completeExceptionally(ex);
1245 >        }
1246  
1249 –        checkCompletedWithWrappedCFException(h, ex);
1247          checkCompletedWithWrappedCFException(g, ex);
1248 +        checkCompletedWithWrappedCFException(f, ex);
1249          assertEquals(0, r.invocationCount);
1252 –        checkCompletedNormally(f, v1);
1250      }}
1251  
1252 <    public void testThenCombine_exceptionalCompletion3() {
1252 >    /**
1253 >     * thenAccept result completes exceptionally if action does
1254 >     */
1255 >    public void testThenAccept_actionFailed() {
1256          for (ExecutionMode m : ExecutionMode.values())
1257 +        for (boolean createIncomplete : new boolean[] { true, false })
1258          for (Integer v1 : new Integer[] { 1, null })
1259      {
1260          final CompletableFuture<Integer> f = new CompletableFuture<>();
1261 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1262 <        final SubtractFunction r = new SubtractFunction();
1263 <        final CFException ex = new CFException();
1264 <
1265 <        g.completeExceptionally(ex);
1266 <        f.complete(v1);
1267 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1261 >        final FailingConsumer r = new FailingConsumer(m);
1262 >        if (!createIncomplete) f.complete(v1);
1263 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1264 >        if (createIncomplete) {
1265 >            checkIncomplete(g);
1266 >            f.complete(v1);
1267 >        }
1268  
1269 <        checkCompletedWithWrappedCFException(h, ex);
1269 <        checkCompletedWithWrappedCFException(g, ex);
1270 <        assertEquals(0, r.invocationCount);
1269 >        checkCompletedWithWrappedCFException(g);
1270          checkCompletedNormally(f, v1);
1271      }}
1272  
1273 <    public void testThenCombine_exceptionalCompletion4() {
1273 >    /**
1274 >     * thenAccept result completes exceptionally if source cancelled
1275 >     */
1276 >    public void testThenAccept_sourceCancelled() {
1277          for (ExecutionMode m : ExecutionMode.values())
1278 <        for (Integer v1 : new Integer[] { 1, null })
1278 >        for (boolean createIncomplete : new boolean[] { true, false })
1279 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1280      {
1281          final CompletableFuture<Integer> f = new CompletableFuture<>();
1282 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1283 <        final SubtractFunction r = new SubtractFunction();
1284 <        final CFException ex = new CFException();
1285 <
1286 <        f.completeExceptionally(ex);
1287 <        g.complete(v1);
1288 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1282 >        final IncAction r = new IncAction();
1283 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1284 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1285 >        if (createIncomplete) {
1286 >            checkIncomplete(g);
1287 >            assertTrue(f.cancel(mayInterruptIfRunning));
1288 >        }
1289  
1290 <        checkCompletedWithWrappedCFException(h, ex);
1291 <        checkCompletedWithWrappedCFException(f, ex);
1290 >        checkCompletedWithWrappedCancellationException(g);
1291 >        checkCancelled(f);
1292          assertEquals(0, r.invocationCount);
1290 –        checkCompletedNormally(g, v1);
1293      }}
1294  
1295      /**
1296 <     * thenCombine result completes exceptionally if action does
1296 >     * thenCombine result completes normally after normal completion
1297 >     * of sources
1298       */
1299 <    public void testThenCombine_actionFailed1() {
1299 >    public void testThenCombine_normalCompletion() {
1300          for (ExecutionMode m : ExecutionMode.values())
1301 +        for (boolean createIncomplete : new boolean[] { true, false })
1302 +        for (boolean fFirst : new boolean[] { true, false })
1303          for (Integer v1 : new Integer[] { 1, null })
1304          for (Integer v2 : new Integer[] { 2, null })
1305      {
1306          final CompletableFuture<Integer> f = new CompletableFuture<>();
1307          final CompletableFuture<Integer> g = new CompletableFuture<>();
1308 <        final FailingBiFunction r = new FailingBiFunction();
1304 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1305 <
1306 <        f.complete(v1);
1307 <        checkIncomplete(h);
1308 <        g.complete(v2);
1309 <
1310 <        checkCompletedWithWrappedCFException(h);
1311 <        checkCompletedNormally(f, v1);
1312 <        checkCompletedNormally(g, v2);
1313 <    }}
1308 >        final SubtractFunction r = new SubtractFunction(m);
1309  
1310 <    public void testThenCombine_actionFailed2() {
1311 <        for (ExecutionMode m : ExecutionMode.values())
1312 <        for (Integer v1 : new Integer[] { 1, null })
1318 <        for (Integer v2 : new Integer[] { 2, null })
1319 <    {
1320 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1321 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1322 <        final FailingBiFunction r = new FailingBiFunction();
1310 >        if (fFirst) f.complete(v1); else g.complete(v2);
1311 >        if (!createIncomplete)
1312 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1313          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1314 +        if (createIncomplete) {
1315 +            checkIncomplete(h);
1316 +            assertEquals(0, r.invocationCount);
1317 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1318 +        }
1319  
1320 <        g.complete(v2);
1326 <        checkIncomplete(h);
1327 <        f.complete(v1);
1328 <
1329 <        checkCompletedWithWrappedCFException(h);
1320 >        checkCompletedNormally(h, subtract(v1, v2));
1321          checkCompletedNormally(f, v1);
1322          checkCompletedNormally(g, v2);
1323 +        assertEquals(1, r.invocationCount);
1324      }}
1325  
1326      /**
1327 <     * thenCombine result completes exceptionally if either source cancelled
1327 >     * thenCombine result completes exceptionally after exceptional
1328 >     * completion of either source
1329       */
1330 <    public void testThenCombine_sourceCancelled1() {
1330 >    public void testThenCombine_exceptionalCompletion() {
1331          for (ExecutionMode m : ExecutionMode.values())
1332 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1332 >        for (boolean createIncomplete : new boolean[] { true, false })
1333 >        for (boolean fFirst : new boolean[] { true, false })
1334          for (Integer v1 : new Integer[] { 1, null })
1335      {
1336          final CompletableFuture<Integer> f = new CompletableFuture<>();
1337          final CompletableFuture<Integer> g = new CompletableFuture<>();
1338 <        final SubtractFunction r = new SubtractFunction();
1339 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1346 <
1347 <        assertTrue(f.cancel(mayInterruptIfRunning));
1348 <        checkIncomplete(h);
1349 <        g.complete(v1);
1350 <
1351 <        checkCompletedWithWrappedCancellationException(h);
1352 <        checkCancelled(f);
1353 <        assertEquals(0, r.invocationCount);
1354 <        checkCompletedNormally(g, v1);
1355 <    }}
1338 >        final CFException ex = new CFException();
1339 >        final SubtractFunction r = new SubtractFunction(m);
1340  
1341 <    public void testThenCombine_sourceCancelled2() {
1342 <        for (ExecutionMode m : ExecutionMode.values())
1343 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1360 <        for (Integer v1 : new Integer[] { 1, null })
1361 <    {
1362 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1363 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1364 <        final SubtractFunction r = new SubtractFunction();
1341 >        (fFirst ? f : g).complete(v1);
1342 >        if (!createIncomplete)
1343 >            (!fFirst ? f : g).completeExceptionally(ex);
1344          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1345 +        if (createIncomplete) {
1346 +            checkIncomplete(h);
1347 +            (!fFirst ? f : g).completeExceptionally(ex);
1348 +        }
1349  
1350 <        assertTrue(g.cancel(mayInterruptIfRunning));
1368 <        checkIncomplete(h);
1369 <        f.complete(v1);
1370 <
1371 <        checkCompletedWithWrappedCancellationException(h);
1372 <        checkCancelled(g);
1350 >        checkCompletedWithWrappedCFException(h, ex);
1351          assertEquals(0, r.invocationCount);
1352 <        checkCompletedNormally(f, v1);
1352 >        checkCompletedNormally(fFirst ? f : g, v1);
1353 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1354      }}
1355  
1356 <    public void testThenCombine_sourceCancelled3() {
1356 >    /**
1357 >     * thenCombine result completes exceptionally if action does
1358 >     */
1359 >    public void testThenCombine_actionFailed() {
1360          for (ExecutionMode m : ExecutionMode.values())
1361 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1361 >        for (boolean fFirst : new boolean[] { true, false })
1362          for (Integer v1 : new Integer[] { 1, null })
1363 +        for (Integer v2 : new Integer[] { 2, null })
1364      {
1365          final CompletableFuture<Integer> f = new CompletableFuture<>();
1366          final CompletableFuture<Integer> g = new CompletableFuture<>();
1367 <        final SubtractFunction r = new SubtractFunction();
1385 <
1386 <        assertTrue(g.cancel(mayInterruptIfRunning));
1387 <        f.complete(v1);
1367 >        final FailingBiFunction r = new FailingBiFunction(m);
1368          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1369  
1370 <        checkCompletedWithWrappedCancellationException(h);
1371 <        checkCancelled(g);
1372 <        assertEquals(0, r.invocationCount);
1370 >        if (fFirst) {
1371 >            f.complete(v1);
1372 >            g.complete(v2);
1373 >        } else {
1374 >            g.complete(v2);
1375 >            f.complete(v1);
1376 >        }
1377 >
1378 >        checkCompletedWithWrappedCFException(h);
1379          checkCompletedNormally(f, v1);
1380 +        checkCompletedNormally(g, v2);
1381      }}
1382  
1383 <    public void testThenCombine_sourceCancelled4() {
1383 >    /**
1384 >     * thenCombine result completes exceptionally if either source cancelled
1385 >     */
1386 >    public void testThenCombine_sourceCancelled() {
1387          for (ExecutionMode m : ExecutionMode.values())
1388          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1389 +        for (boolean createIncomplete : new boolean[] { true, false })
1390 +        for (boolean fFirst : new boolean[] { true, false })
1391          for (Integer v1 : new Integer[] { 1, null })
1392      {
1393          final CompletableFuture<Integer> f = new CompletableFuture<>();
1394          final CompletableFuture<Integer> g = new CompletableFuture<>();
1395 <        final SubtractFunction r = new SubtractFunction();
1395 >        final SubtractFunction r = new SubtractFunction(m);
1396  
1397 <        assertTrue(f.cancel(mayInterruptIfRunning));
1398 <        g.complete(v1);
1397 >        (fFirst ? f : g).complete(v1);
1398 >        if (!createIncomplete)
1399 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1400          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1401 +        if (createIncomplete) {
1402 +            checkIncomplete(h);
1403 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1404 +        }
1405  
1406          checkCompletedWithWrappedCancellationException(h);
1407 <        checkCancelled(f);
1407 >        checkCancelled(!fFirst ? f : g);
1408          assertEquals(0, r.invocationCount);
1409 <        checkCompletedNormally(g, v1);
1409 >        checkCompletedNormally(fFirst ? f : g, v1);
1410      }}
1411  
1412      /**
1413       * thenAcceptBoth result completes normally after normal
1414       * completion of sources
1415       */
1416 <    public void testThenAcceptBoth_normalCompletion1() {
1420 <        for (ExecutionMode m : ExecutionMode.values())
1421 <        for (Integer v1 : new Integer[] { 1, null })
1422 <        for (Integer v2 : new Integer[] { 2, null })
1423 <    {
1424 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1425 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1426 <        final SubtractAction r = new SubtractAction();
1427 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1428 <
1429 <        f.complete(v1);
1430 <        checkIncomplete(h);
1431 <        assertEquals(0, r.invocationCount);
1432 <        g.complete(v2);
1433 <
1434 <        checkCompletedNormally(h, null);
1435 <        assertEquals(subtract(v1, v2), r.value);
1436 <        checkCompletedNormally(f, v1);
1437 <        checkCompletedNormally(g, v2);
1438 <    }}
1439 <
1440 <    public void testThenAcceptBoth_normalCompletion2() {
1441 <        for (ExecutionMode m : ExecutionMode.values())
1442 <        for (Integer v1 : new Integer[] { 1, null })
1443 <        for (Integer v2 : new Integer[] { 2, null })
1444 <    {
1445 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1446 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1447 <        final SubtractAction r = new SubtractAction();
1448 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1449 <
1450 <        g.complete(v2);
1451 <        checkIncomplete(h);
1452 <        assertEquals(0, r.invocationCount);
1453 <        f.complete(v1);
1454 <
1455 <        checkCompletedNormally(h, null);
1456 <        assertEquals(subtract(v1, v2), r.value);
1457 <        checkCompletedNormally(f, v1);
1458 <        checkCompletedNormally(g, v2);
1459 <    }}
1460 <
1461 <    public void testThenAcceptBoth_normalCompletion3() {
1462 <        for (ExecutionMode m : ExecutionMode.values())
1463 <        for (Integer v1 : new Integer[] { 1, null })
1464 <        for (Integer v2 : new Integer[] { 2, null })
1465 <    {
1466 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1467 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1468 <        final SubtractAction r = new SubtractAction();
1469 <
1470 <        g.complete(v2);
1471 <        f.complete(v1);
1472 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1473 <
1474 <        checkCompletedNormally(h, null);
1475 <        assertEquals(subtract(v1, v2), r.value);
1476 <        checkCompletedNormally(f, v1);
1477 <        checkCompletedNormally(g, v2);
1478 <    }}
1479 <
1480 <    public void testThenAcceptBoth_normalCompletion4() {
1416 >    public void testThenAcceptBoth_normalCompletion() {
1417          for (ExecutionMode m : ExecutionMode.values())
1418 +        for (boolean createIncomplete : new boolean[] { true, false })
1419 +        for (boolean fFirst : new boolean[] { true, false })
1420          for (Integer v1 : new Integer[] { 1, null })
1421          for (Integer v2 : new Integer[] { 2, null })
1422      {
1423          final CompletableFuture<Integer> f = new CompletableFuture<>();
1424          final CompletableFuture<Integer> g = new CompletableFuture<>();
1425 <        final SubtractAction r = new SubtractAction();
1425 >        final SubtractAction r = new SubtractAction(m);
1426  
1427 <        f.complete(v1);
1428 <        g.complete(v2);
1427 >        if (fFirst) f.complete(v1); else g.complete(v2);
1428 >        if (!createIncomplete)
1429 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1430          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1431 +        if (createIncomplete) {
1432 +            checkIncomplete(h);
1433 +            assertEquals(0, r.invocationCount);
1434 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1435 +        }
1436  
1437          checkCompletedNormally(h, null);
1438          assertEquals(subtract(v1, v2), r.value);
# Line 1500 | Line 1444 | public class CompletableFutureTest exten
1444       * thenAcceptBoth result completes exceptionally after exceptional
1445       * completion of either source
1446       */
1447 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1504 <        for (ExecutionMode m : ExecutionMode.values())
1505 <        for (Integer v1 : new Integer[] { 1, null })
1506 <    {
1507 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1508 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1509 <        final SubtractAction r = new SubtractAction();
1510 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1511 <        final CFException ex = new CFException();
1512 <
1513 <        f.completeExceptionally(ex);
1514 <        checkIncomplete(h);
1515 <        g.complete(v1);
1516 <
1517 <        checkCompletedWithWrappedCFException(h, ex);
1518 <        checkCompletedWithWrappedCFException(f, ex);
1519 <        assertEquals(0, r.invocationCount);
1520 <        checkCompletedNormally(g, v1);
1521 <    }}
1522 <
1523 <    public void testThenAcceptBoth_exceptionalCompletion2() {
1524 <        for (ExecutionMode m : ExecutionMode.values())
1525 <        for (Integer v1 : new Integer[] { 1, null })
1526 <    {
1527 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1528 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1529 <        final SubtractAction r = new SubtractAction();
1530 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1531 <        final CFException ex = new CFException();
1532 <
1533 <        g.completeExceptionally(ex);
1534 <        checkIncomplete(h);
1535 <        f.complete(v1);
1536 <
1537 <        checkCompletedWithWrappedCFException(h, ex);
1538 <        checkCompletedWithWrappedCFException(g, ex);
1539 <        assertEquals(0, r.invocationCount);
1540 <        checkCompletedNormally(f, v1);
1541 <    }}
1542 <
1543 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1544 <        for (ExecutionMode m : ExecutionMode.values())
1545 <        for (Integer v1 : new Integer[] { 1, null })
1546 <    {
1547 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1548 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1549 <        final SubtractAction r = new SubtractAction();
1550 <        final CFException ex = new CFException();
1551 <
1552 <        g.completeExceptionally(ex);
1553 <        f.complete(v1);
1554 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1555 <
1556 <        checkCompletedWithWrappedCFException(h, ex);
1557 <        checkCompletedWithWrappedCFException(g, ex);
1558 <        assertEquals(0, r.invocationCount);
1559 <        checkCompletedNormally(f, v1);
1560 <    }}
1561 <
1562 <    public void testThenAcceptBoth_exceptionalCompletion4() {
1447 >    public void testThenAcceptBoth_exceptionalCompletion() {
1448          for (ExecutionMode m : ExecutionMode.values())
1449 +        for (boolean createIncomplete : new boolean[] { true, false })
1450 +        for (boolean fFirst : new boolean[] { true, false })
1451          for (Integer v1 : new Integer[] { 1, null })
1452      {
1453          final CompletableFuture<Integer> f = new CompletableFuture<>();
1454          final CompletableFuture<Integer> g = new CompletableFuture<>();
1568 –        final SubtractAction r = new SubtractAction();
1455          final CFException ex = new CFException();
1456 +        final SubtractAction r = new SubtractAction(m);
1457  
1458 <        f.completeExceptionally(ex);
1459 <        g.complete(v1);
1458 >        (fFirst ? f : g).complete(v1);
1459 >        if (!createIncomplete)
1460 >            (!fFirst ? f : g).completeExceptionally(ex);
1461          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1462 +        if (createIncomplete) {
1463 +            checkIncomplete(h);
1464 +            (!fFirst ? f : g).completeExceptionally(ex);
1465 +        }
1466  
1467          checkCompletedWithWrappedCFException(h, ex);
1576 –        checkCompletedWithWrappedCFException(f, ex);
1468          assertEquals(0, r.invocationCount);
1469 <        checkCompletedNormally(g, v1);
1469 >        checkCompletedNormally(fFirst ? f : g, v1);
1470 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1471      }}
1472  
1473      /**
1474       * thenAcceptBoth result completes exceptionally if action does
1475       */
1476 <    public void testThenAcceptBoth_actionFailed1() {
1585 <        for (ExecutionMode m : ExecutionMode.values())
1586 <        for (Integer v1 : new Integer[] { 1, null })
1587 <        for (Integer v2 : new Integer[] { 2, null })
1588 <    {
1589 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1590 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1591 <        final FailingBiConsumer r = new FailingBiConsumer();
1592 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1593 <
1594 <        f.complete(v1);
1595 <        checkIncomplete(h);
1596 <        g.complete(v2);
1597 <
1598 <        checkCompletedWithWrappedCFException(h);
1599 <        checkCompletedNormally(f, v1);
1600 <        checkCompletedNormally(g, v2);
1601 <    }}
1602 <
1603 <    public void testThenAcceptBoth_actionFailed2() {
1476 >    public void testThenAcceptBoth_actionFailed() {
1477          for (ExecutionMode m : ExecutionMode.values())
1478 +        for (boolean fFirst : new boolean[] { true, false })
1479          for (Integer v1 : new Integer[] { 1, null })
1480          for (Integer v2 : new Integer[] { 2, null })
1481      {
1482          final CompletableFuture<Integer> f = new CompletableFuture<>();
1483          final CompletableFuture<Integer> g = new CompletableFuture<>();
1484 <        final FailingBiConsumer r = new FailingBiConsumer();
1484 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1485          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1486  
1487 <        g.complete(v2);
1488 <        checkIncomplete(h);
1489 <        f.complete(v1);
1487 >        if (fFirst) {
1488 >            f.complete(v1);
1489 >            g.complete(v2);
1490 >        } else {
1491 >            g.complete(v2);
1492 >            f.complete(v1);
1493 >        }
1494  
1495          checkCompletedWithWrappedCFException(h);
1496          checkCompletedNormally(f, v1);
# Line 1622 | Line 1500 | public class CompletableFutureTest exten
1500      /**
1501       * thenAcceptBoth result completes exceptionally if either source cancelled
1502       */
1503 <    public void testThenAcceptBoth_sourceCancelled1() {
1626 <        for (ExecutionMode m : ExecutionMode.values())
1627 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1628 <        for (Integer v1 : new Integer[] { 1, null })
1629 <    {
1630 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1631 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1632 <        final SubtractAction r = new SubtractAction();
1633 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1634 <
1635 <        assertTrue(f.cancel(mayInterruptIfRunning));
1636 <        checkIncomplete(h);
1637 <        g.complete(v1);
1638 <
1639 <        checkCompletedWithWrappedCancellationException(h);
1640 <        checkCancelled(f);
1641 <        assertEquals(0, r.invocationCount);
1642 <        checkCompletedNormally(g, v1);
1643 <    }}
1644 <
1645 <    public void testThenAcceptBoth_sourceCancelled2() {
1646 <        for (ExecutionMode m : ExecutionMode.values())
1647 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1648 <        for (Integer v1 : new Integer[] { 1, null })
1649 <    {
1650 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1651 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1652 <        final SubtractAction r = new SubtractAction();
1653 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1654 <
1655 <        assertTrue(g.cancel(mayInterruptIfRunning));
1656 <        checkIncomplete(h);
1657 <        f.complete(v1);
1658 <
1659 <        checkCompletedWithWrappedCancellationException(h);
1660 <        checkCancelled(g);
1661 <        assertEquals(0, r.invocationCount);
1662 <        checkCompletedNormally(f, v1);
1663 <    }}
1664 <
1665 <    public void testThenAcceptBoth_sourceCancelled3() {
1666 <        for (ExecutionMode m : ExecutionMode.values())
1667 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1668 <        for (Integer v1 : new Integer[] { 1, null })
1669 <    {
1670 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1671 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1672 <        final SubtractAction r = new SubtractAction();
1673 <
1674 <        assertTrue(g.cancel(mayInterruptIfRunning));
1675 <        f.complete(v1);
1676 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1677 <
1678 <        checkCompletedWithWrappedCancellationException(h);
1679 <        checkCancelled(g);
1680 <        assertEquals(0, r.invocationCount);
1681 <        checkCompletedNormally(f, v1);
1682 <    }}
1683 <
1684 <    public void testThenAcceptBoth_sourceCancelled4() {
1503 >    public void testThenAcceptBoth_sourceCancelled() {
1504          for (ExecutionMode m : ExecutionMode.values())
1505          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1506 +        for (boolean createIncomplete : new boolean[] { true, false })
1507 +        for (boolean fFirst : new boolean[] { true, false })
1508          for (Integer v1 : new Integer[] { 1, null })
1509      {
1510          final CompletableFuture<Integer> f = new CompletableFuture<>();
1511          final CompletableFuture<Integer> g = new CompletableFuture<>();
1512 <        final SubtractAction r = new SubtractAction();
1512 >        final SubtractAction r = new SubtractAction(m);
1513  
1514 <        assertTrue(f.cancel(mayInterruptIfRunning));
1515 <        g.complete(v1);
1514 >        (fFirst ? f : g).complete(v1);
1515 >        if (!createIncomplete)
1516 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1517          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1518 +        if (createIncomplete) {
1519 +            checkIncomplete(h);
1520 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1521 +        }
1522  
1523          checkCompletedWithWrappedCancellationException(h);
1524 <        checkCancelled(f);
1524 >        checkCancelled(!fFirst ? f : g);
1525          assertEquals(0, r.invocationCount);
1526 <        checkCompletedNormally(g, v1);
1526 >        checkCompletedNormally(fFirst ? f : g, v1);
1527      }}
1528  
1529      /**
1530       * runAfterBoth result completes normally after normal
1531       * completion of sources
1532       */
1533 <    public void testRunAfterBoth_normalCompletion1() {
1708 <        for (ExecutionMode m : ExecutionMode.values())
1709 <        for (Integer v1 : new Integer[] { 1, null })
1710 <        for (Integer v2 : new Integer[] { 2, null })
1711 <    {
1712 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1713 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1714 <        final Noop r = new Noop();
1715 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1716 <
1717 <        f.complete(v1);
1718 <        checkIncomplete(h);
1719 <        assertEquals(0, r.invocationCount);
1720 <        g.complete(v2);
1721 <
1722 <        checkCompletedNormally(h, null);
1723 <        assertEquals(1, r.invocationCount);
1724 <        checkCompletedNormally(f, v1);
1725 <        checkCompletedNormally(g, v2);
1726 <    }}
1727 <
1728 <    public void testRunAfterBoth_normalCompletion2() {
1729 <        for (ExecutionMode m : ExecutionMode.values())
1730 <        for (Integer v1 : new Integer[] { 1, null })
1731 <        for (Integer v2 : new Integer[] { 2, null })
1732 <    {
1733 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1734 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1735 <        final Noop r = new Noop();
1736 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1737 <
1738 <        g.complete(v2);
1739 <        checkIncomplete(h);
1740 <        assertEquals(0, r.invocationCount);
1741 <        f.complete(v1);
1742 <
1743 <        checkCompletedNormally(h, null);
1744 <        assertEquals(1, r.invocationCount);
1745 <        checkCompletedNormally(f, v1);
1746 <        checkCompletedNormally(g, v2);
1747 <    }}
1748 <
1749 <    public void testRunAfterBoth_normalCompletion3() {
1750 <        for (ExecutionMode m : ExecutionMode.values())
1751 <        for (Integer v1 : new Integer[] { 1, null })
1752 <        for (Integer v2 : new Integer[] { 2, null })
1753 <    {
1754 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1755 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1756 <        final Noop r = new Noop();
1757 <
1758 <        g.complete(v2);
1759 <        f.complete(v1);
1760 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1761 <
1762 <        checkCompletedNormally(h, null);
1763 <        assertEquals(1, r.invocationCount);
1764 <        checkCompletedNormally(f, v1);
1765 <        checkCompletedNormally(g, v2);
1766 <    }}
1767 <
1768 <    public void testRunAfterBoth_normalCompletion4() {
1533 >    public void testRunAfterBoth_normalCompletion() {
1534          for (ExecutionMode m : ExecutionMode.values())
1535 +        for (boolean createIncomplete : new boolean[] { true, false })
1536 +        for (boolean fFirst : new boolean[] { true, false })
1537          for (Integer v1 : new Integer[] { 1, null })
1538          for (Integer v2 : new Integer[] { 2, null })
1539      {
1540          final CompletableFuture<Integer> f = new CompletableFuture<>();
1541          final CompletableFuture<Integer> g = new CompletableFuture<>();
1542 <        final Noop r = new Noop();
1542 >        final Noop r = new Noop(m);
1543  
1544 <        f.complete(v1);
1545 <        g.complete(v2);
1544 >        if (fFirst) f.complete(v1); else g.complete(v2);
1545 >        if (!createIncomplete)
1546 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1547          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1548 +        if (createIncomplete) {
1549 +            checkIncomplete(h);
1550 +            assertEquals(0, r.invocationCount);
1551 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1552 +        }
1553  
1554          checkCompletedNormally(h, null);
1555          assertEquals(1, r.invocationCount);
# Line 1788 | Line 1561 | public class CompletableFutureTest exten
1561       * runAfterBoth result completes exceptionally after exceptional
1562       * completion of either source
1563       */
1564 <    public void testRunAfterBoth_exceptionalCompletion1() {
1792 <        for (ExecutionMode m : ExecutionMode.values())
1793 <        for (Integer v1 : new Integer[] { 1, null })
1794 <    {
1795 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1796 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1797 <        final Noop r = new Noop();
1798 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1799 <        final CFException ex = new CFException();
1800 <
1801 <        f.completeExceptionally(ex);
1802 <        checkIncomplete(h);
1803 <        g.complete(v1);
1804 <
1805 <        checkCompletedWithWrappedCFException(h, ex);
1806 <        checkCompletedWithWrappedCFException(f, ex);
1807 <        assertEquals(0, r.invocationCount);
1808 <        checkCompletedNormally(g, v1);
1809 <    }}
1810 <
1811 <    public void testRunAfterBoth_exceptionalCompletion2() {
1812 <        for (ExecutionMode m : ExecutionMode.values())
1813 <        for (Integer v1 : new Integer[] { 1, null })
1814 <    {
1815 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1816 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1817 <        final Noop r = new Noop();
1818 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1819 <        final CFException ex = new CFException();
1820 <
1821 <        g.completeExceptionally(ex);
1822 <        checkIncomplete(h);
1823 <        f.complete(v1);
1824 <
1825 <        checkCompletedWithWrappedCFException(h, ex);
1826 <        checkCompletedWithWrappedCFException(g, ex);
1827 <        assertEquals(0, r.invocationCount);
1828 <        checkCompletedNormally(f, v1);
1829 <    }}
1830 <
1831 <    public void testRunAfterBoth_exceptionalCompletion3() {
1832 <        for (ExecutionMode m : ExecutionMode.values())
1833 <        for (Integer v1 : new Integer[] { 1, null })
1834 <    {
1835 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1836 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1837 <        final Noop r = new Noop();
1838 <        final CFException ex = new CFException();
1839 <
1840 <        g.completeExceptionally(ex);
1841 <        f.complete(v1);
1842 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1843 <
1844 <        checkCompletedWithWrappedCFException(h, ex);
1845 <        checkCompletedWithWrappedCFException(g, ex);
1846 <        assertEquals(0, r.invocationCount);
1847 <        checkCompletedNormally(f, v1);
1848 <    }}
1849 <
1850 <    public void testRunAfterBoth_exceptionalCompletion4() {
1564 >    public void testRunAfterBoth_exceptionalCompletion() {
1565          for (ExecutionMode m : ExecutionMode.values())
1566 +        for (boolean createIncomplete : new boolean[] { true, false })
1567 +        for (boolean fFirst : new boolean[] { true, false })
1568          for (Integer v1 : new Integer[] { 1, null })
1569      {
1570          final CompletableFuture<Integer> f = new CompletableFuture<>();
1571          final CompletableFuture<Integer> g = new CompletableFuture<>();
1856 –        final Noop r = new Noop();
1572          final CFException ex = new CFException();
1573 +        final Noop r = new Noop(m);
1574  
1575 <        f.completeExceptionally(ex);
1576 <        g.complete(v1);
1575 >        (fFirst ? f : g).complete(v1);
1576 >        if (!createIncomplete)
1577 >            (!fFirst ? f : g).completeExceptionally(ex);
1578          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1579 +        if (createIncomplete) {
1580 +            checkIncomplete(h);
1581 +            (!fFirst ? f : g).completeExceptionally(ex);
1582 +        }
1583  
1584          checkCompletedWithWrappedCFException(h, ex);
1864 –        checkCompletedWithWrappedCFException(f, ex);
1585          assertEquals(0, r.invocationCount);
1586 <        checkCompletedNormally(g, v1);
1586 >        checkCompletedNormally(fFirst ? f : g, v1);
1587 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1588      }}
1589  
1590      /**
1591       * runAfterBoth result completes exceptionally if action does
1592       */
1593 <    public void testRunAfterBoth_actionFailed1() {
1873 <        for (ExecutionMode m : ExecutionMode.values())
1874 <        for (Integer v1 : new Integer[] { 1, null })
1875 <        for (Integer v2 : new Integer[] { 2, null })
1876 <    {
1877 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1878 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1879 <        final FailingNoop r = new FailingNoop();
1880 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1881 <
1882 <        f.complete(v1);
1883 <        checkIncomplete(h);
1884 <        g.complete(v2);
1885 <
1886 <        checkCompletedWithWrappedCFException(h);
1887 <        checkCompletedNormally(f, v1);
1888 <        checkCompletedNormally(g, v2);
1889 <    }}
1890 <
1891 <    public void testRunAfterBoth_actionFailed2() {
1593 >    public void testRunAfterBoth_actionFailed() {
1594          for (ExecutionMode m : ExecutionMode.values())
1595 +        for (boolean fFirst : new boolean[] { true, false })
1596          for (Integer v1 : new Integer[] { 1, null })
1597          for (Integer v2 : new Integer[] { 2, null })
1598      {
1599          final CompletableFuture<Integer> f = new CompletableFuture<>();
1600          final CompletableFuture<Integer> g = new CompletableFuture<>();
1601 <        final FailingNoop r = new FailingNoop();
1899 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1601 >        final FailingRunnable r = new FailingRunnable(m);
1602  
1603 <        g.complete(v2);
1604 <        checkIncomplete(h);
1605 <        f.complete(v1);
1603 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1604 >        if (fFirst) {
1605 >            f.complete(v1);
1606 >            g.complete(v2);
1607 >        } else {
1608 >            g.complete(v2);
1609 >            f.complete(v1);
1610 >        }
1611 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1612  
1613 <        checkCompletedWithWrappedCFException(h);
1613 >        checkCompletedWithWrappedCFException(h1);
1614 >        checkCompletedWithWrappedCFException(h2);
1615          checkCompletedNormally(f, v1);
1616          checkCompletedNormally(g, v2);
1617      }}
# Line 1910 | Line 1619 | public class CompletableFutureTest exten
1619      /**
1620       * runAfterBoth result completes exceptionally if either source cancelled
1621       */
1622 <    public void testRunAfterBoth_sourceCancelled1() {
1914 <        for (ExecutionMode m : ExecutionMode.values())
1915 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1916 <        for (Integer v1 : new Integer[] { 1, null })
1917 <    {
1918 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1919 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1920 <        final Noop r = new Noop();
1921 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1922 <
1923 <        assertTrue(f.cancel(mayInterruptIfRunning));
1924 <        checkIncomplete(h);
1925 <        g.complete(v1);
1926 <
1927 <        checkCompletedWithWrappedCancellationException(h);
1928 <        checkCancelled(f);
1929 <        assertEquals(0, r.invocationCount);
1930 <        checkCompletedNormally(g, v1);
1931 <    }}
1932 <
1933 <    public void testRunAfterBoth_sourceCancelled2() {
1934 <        for (ExecutionMode m : ExecutionMode.values())
1935 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1936 <        for (Integer v1 : new Integer[] { 1, null })
1937 <    {
1938 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1939 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1940 <        final Noop r = new Noop();
1941 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1942 <
1943 <        assertTrue(g.cancel(mayInterruptIfRunning));
1944 <        checkIncomplete(h);
1945 <        f.complete(v1);
1946 <
1947 <        checkCompletedWithWrappedCancellationException(h);
1948 <        checkCancelled(g);
1949 <        assertEquals(0, r.invocationCount);
1950 <        checkCompletedNormally(f, v1);
1951 <    }}
1952 <
1953 <    public void testRunAfterBoth_sourceCancelled3() {
1622 >    public void testRunAfterBoth_sourceCancelled() {
1623          for (ExecutionMode m : ExecutionMode.values())
1624          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1625 +        for (boolean createIncomplete : new boolean[] { true, false })
1626 +        for (boolean fFirst : new boolean[] { true, false })
1627          for (Integer v1 : new Integer[] { 1, null })
1628      {
1629          final CompletableFuture<Integer> f = new CompletableFuture<>();
1630          final CompletableFuture<Integer> g = new CompletableFuture<>();
1631 <        final Noop r = new Noop();
1961 <
1962 <        assertTrue(g.cancel(mayInterruptIfRunning));
1963 <        f.complete(v1);
1964 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1965 <
1966 <        checkCompletedWithWrappedCancellationException(h);
1967 <        checkCancelled(g);
1968 <        assertEquals(0, r.invocationCount);
1969 <        checkCompletedNormally(f, v1);
1970 <    }}
1631 >        final Noop r = new Noop(m);
1632  
1972 –    public void testRunAfterBoth_sourceCancelled4() {
1973 –        for (ExecutionMode m : ExecutionMode.values())
1974 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1975 –        for (Integer v1 : new Integer[] { 1, null })
1976 –    {
1977 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1978 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1979 –        final Noop r = new Noop();
1633  
1634 <        assertTrue(f.cancel(mayInterruptIfRunning));
1635 <        g.complete(v1);
1634 >        (fFirst ? f : g).complete(v1);
1635 >        if (!createIncomplete)
1636 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1637          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1638 +        if (createIncomplete) {
1639 +            checkIncomplete(h);
1640 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1641 +        }
1642  
1643          checkCompletedWithWrappedCancellationException(h);
1644 <        checkCancelled(f);
1644 >        checkCancelled(!fFirst ? f : g);
1645          assertEquals(0, r.invocationCount);
1646 <        checkCompletedNormally(g, v1);
1646 >        checkCompletedNormally(fFirst ? f : g, v1);
1647      }}
1648  
1649      /**
1650       * applyToEither result completes normally after normal completion
1651       * of either source
1652       */
1653 <    public void testApplyToEither_normalCompletion1() {
1653 >    public void testApplyToEither_normalCompletion() {
1654          for (ExecutionMode m : ExecutionMode.values())
1655 +        for (boolean createIncomplete : new boolean[] { true, false })
1656 +        for (boolean fFirst : new boolean[] { true, false })
1657          for (Integer v1 : new Integer[] { 1, null })
1658          for (Integer v2 : new Integer[] { 2, null })
1659      {
1660          final CompletableFuture<Integer> f = new CompletableFuture<>();
1661          final CompletableFuture<Integer> g = new CompletableFuture<>();
1662 <        final IncFunction r = new IncFunction();
2003 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1662 >        final IncFunction r = new IncFunction(m);
1663  
1664 <        f.complete(v1);
1665 <        checkCompletedNormally(h, inc(v1));
1666 <        g.complete(v2);
1664 >        if (!createIncomplete)
1665 >            if (fFirst) f.complete(v1); else g.complete(v2);
1666 >        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1667 >        if (createIncomplete) {
1668 >            checkIncomplete(h);
1669 >            assertEquals(0, r.invocationCount);
1670 >            if (fFirst) f.complete(v1); else g.complete(v2);
1671 >        }
1672 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1673 >        if (!fFirst) f.complete(v1); else g.complete(v2);
1674  
1675          checkCompletedNormally(f, v1);
1676          checkCompletedNormally(g, v2);
1677 <        checkCompletedNormally(h, inc(v1));
1677 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1678      }}
1679  
1680 <    public void testApplyToEither_normalCompletion2() {
1680 >    public void testApplyToEither_normalCompletionBothAvailable() {
1681          for (ExecutionMode m : ExecutionMode.values())
1682 +        for (boolean fFirst : new boolean[] { true, false })
1683          for (Integer v1 : new Integer[] { 1, null })
1684          for (Integer v2 : new Integer[] { 2, null })
1685      {
1686          final CompletableFuture<Integer> f = new CompletableFuture<>();
1687          final CompletableFuture<Integer> g = new CompletableFuture<>();
1688 <        final IncFunction r = new IncFunction();
2022 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2023 <
2024 <        g.complete(v2);
2025 <        checkCompletedNormally(h, inc(v2));
2026 <        f.complete(v1);
1688 >        final IncFunction r = new IncFunction(m);
1689  
1690 <        checkCompletedNormally(f, v1);
1691 <        checkCompletedNormally(g, v2);
1692 <        checkCompletedNormally(h, inc(v2));
1693 <        }}
1694 <
1695 <    public void testApplyToEither_normalCompletion3() {
1696 <        for (ExecutionMode m : ExecutionMode.values())
2035 <        for (Integer v1 : new Integer[] { 1, null })
2036 <        for (Integer v2 : new Integer[] { 2, null })
2037 <    {
2038 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2039 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2040 <        final IncFunction r = new IncFunction();
1690 >        if (fFirst) {
1691 >            f.complete(v1);
1692 >            g.complete(v2);
1693 >        } else {
1694 >            g.complete(v2);
1695 >            f.complete(v1);
1696 >        }
1697  
2042 –        f.complete(v1);
2043 –        g.complete(v2);
1698          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1699  
1700          checkCompletedNormally(f, v1);
# Line 2058 | Line 1712 | public class CompletableFutureTest exten
1712       */
1713      public void testApplyToEither_exceptionalCompletion1() {
1714          for (ExecutionMode m : ExecutionMode.values())
1715 +        for (boolean createIncomplete : new boolean[] { true, false })
1716 +        for (boolean fFirst : new boolean[] { true, false })
1717          for (Integer v1 : new Integer[] { 1, null })
1718      {
1719          final CompletableFuture<Integer> f = new CompletableFuture<>();
1720          final CompletableFuture<Integer> g = new CompletableFuture<>();
2065 –        final IncFunction r = new IncFunction();
2066 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1721          final CFException ex = new CFException();
1722 +        final IncFunction r = new IncFunction(m);
1723  
1724 <        f.completeExceptionally(ex);
2070 <        checkCompletedWithWrappedCFException(h, ex);
2071 <        g.complete(v1);
2072 <
2073 <        assertEquals(0, r.invocationCount);
2074 <        checkCompletedNormally(g, v1);
2075 <        checkCompletedWithWrappedCFException(f, ex);
2076 <        checkCompletedWithWrappedCFException(h, ex);
2077 <    }}
2078 <
2079 <    public void testApplyToEither_exceptionalCompletion2() {
2080 <        for (ExecutionMode m : ExecutionMode.values())
2081 <        for (Integer v1 : new Integer[] { 1, null })
2082 <    {
2083 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2084 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2085 <        final IncFunction r = new IncFunction();
1724 >        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1725          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1726 <        final CFException ex = new CFException();
1726 >        if (createIncomplete) {
1727 >            checkIncomplete(h);
1728 >            assertEquals(0, r.invocationCount);
1729 >            (fFirst ? f : g).completeExceptionally(ex);
1730 >        }
1731  
2089 –        g.completeExceptionally(ex);
1732          checkCompletedWithWrappedCFException(h, ex);
1733 <        f.complete(v1);
1733 >        (!fFirst ? f : g).complete(v1);
1734  
1735          assertEquals(0, r.invocationCount);
1736 <        checkCompletedNormally(f, v1);
1737 <        checkCompletedWithWrappedCFException(g, ex);
1736 >        checkCompletedNormally(!fFirst ? f : g, v1);
1737 >        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1738          checkCompletedWithWrappedCFException(h, ex);
1739      }}
1740  
1741 <    public void testApplyToEither_exceptionalCompletion3() {
1741 >    public void testApplyToEither_exceptionalCompletion2() {
1742          for (ExecutionMode m : ExecutionMode.values())
1743 +        for (boolean reverseArgs : new boolean[] { true, false })
1744 +        for (boolean fFirst : new boolean[] { true, false })
1745          for (Integer v1 : new Integer[] { 1, null })
1746      {
1747          final CompletableFuture<Integer> f = new CompletableFuture<>();
1748          final CompletableFuture<Integer> g = new CompletableFuture<>();
1749 <        final IncFunction r = new IncFunction();
1749 >        final IncFunction r1 = new IncFunction(m);
1750 >        final IncFunction r2 = new IncFunction(m);
1751          final CFException ex = new CFException();
1752 <
1753 <        g.completeExceptionally(ex);
1754 <        f.complete(v1);
1755 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1752 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1753 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1754 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1755 >        if (fFirst) {
1756 >            f.complete(v1);
1757 >            g.completeExceptionally(ex);
1758 >        } else {
1759 >            g.completeExceptionally(ex);
1760 >            f.complete(v1);
1761 >        }
1762 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1763  
1764          // unspecified behavior
2113 –        Integer v;
1765          try {
1766 <            assertEquals(inc(v1), h.join());
1767 <            assertEquals(1, r.invocationCount);
1766 >            assertEquals(inc(v1), h1.join());
1767 >            assertEquals(1, r1.invocationCount);
1768          } catch (CompletionException ok) {
1769 <            checkCompletedWithWrappedCFException(h, ex);
1770 <            assertEquals(0, r.invocationCount);
1769 >            checkCompletedWithWrappedCFException(h1, ex);
1770 >            assertEquals(0, r1.invocationCount);
1771          }
1772  
2122 –        checkCompletedWithWrappedCFException(g, ex);
2123 –        checkCompletedNormally(f, v1);
2124 –    }}
2125 –
2126 –    public void testApplyToEither_exceptionalCompletion4() {
2127 –        for (ExecutionMode m : ExecutionMode.values())
2128 –        for (Integer v1 : new Integer[] { 1, null })
2129 –    {
2130 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2131 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2132 –        final IncFunction r = new IncFunction();
2133 –        final CFException ex = new CFException();
2134 –
2135 –        f.completeExceptionally(ex);
2136 –        g.complete(v1);
2137 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2138 –
2139 –        // unspecified behavior
2140 –        Integer v;
1773          try {
1774 <            assertEquals(inc(v1), h.join());
1775 <            assertEquals(1, r.invocationCount);
1774 >            assertEquals(inc(v1), h2.join());
1775 >            assertEquals(1, r2.invocationCount);
1776          } catch (CompletionException ok) {
1777 <            checkCompletedWithWrappedCFException(h, ex);
1778 <            assertEquals(0, r.invocationCount);
1777 >            checkCompletedWithWrappedCFException(h2, ex);
1778 >            assertEquals(0, r2.invocationCount);
1779          }
1780  
1781 <        checkCompletedWithWrappedCFException(f, ex);
1782 <        checkCompletedNormally(g, v1);
1781 >        checkCompletedWithWrappedCFException(g, ex);
1782 >        checkCompletedNormally(f, v1);
1783      }}
1784  
1785      /**
# Line 2160 | Line 1792 | public class CompletableFutureTest exten
1792      {
1793          final CompletableFuture<Integer> f = new CompletableFuture<>();
1794          final CompletableFuture<Integer> g = new CompletableFuture<>();
1795 <        final FailingFunction r = new FailingFunction();
1795 >        final FailingFunction r = new FailingFunction(m);
1796          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1797  
1798          f.complete(v1);
# Line 2177 | Line 1809 | public class CompletableFutureTest exten
1809      {
1810          final CompletableFuture<Integer> f = new CompletableFuture<>();
1811          final CompletableFuture<Integer> g = new CompletableFuture<>();
1812 <        final FailingFunction r = new FailingFunction();
1812 >        final FailingFunction r = new FailingFunction(m);
1813          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1814  
1815          g.complete(v2);
# Line 2193 | Line 1825 | public class CompletableFutureTest exten
1825      public void testApplyToEither_sourceCancelled1() {
1826          for (ExecutionMode m : ExecutionMode.values())
1827          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1828 +        for (boolean createIncomplete : new boolean[] { true, false })
1829 +        for (boolean fFirst : new boolean[] { true, false })
1830          for (Integer v1 : new Integer[] { 1, null })
1831      {
1832          final CompletableFuture<Integer> f = new CompletableFuture<>();
1833          final CompletableFuture<Integer> g = new CompletableFuture<>();
1834 <        final IncFunction r = new IncFunction();
2201 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2202 <
2203 <        assertTrue(f.cancel(mayInterruptIfRunning));
2204 <        checkCompletedWithWrappedCancellationException(h);
2205 <        g.complete(v1);
2206 <
2207 <        checkCancelled(f);
2208 <        assertEquals(0, r.invocationCount);
2209 <        checkCompletedNormally(g, v1);
2210 <        checkCompletedWithWrappedCancellationException(h);
2211 <    }}
1834 >        final IncFunction r = new IncFunction(m);
1835  
1836 <    public void testApplyToEither_sourceCancelled2() {
2214 <        for (ExecutionMode m : ExecutionMode.values())
2215 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2216 <        for (Integer v1 : new Integer[] { 1, null })
2217 <    {
2218 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2219 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2220 <        final IncFunction r = new IncFunction();
1836 >        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1837          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1838 +        if (createIncomplete) {
1839 +            checkIncomplete(h);
1840 +            assertEquals(0, r.invocationCount);
1841 +            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1842 +        }
1843  
2223 –        assertTrue(g.cancel(mayInterruptIfRunning));
1844          checkCompletedWithWrappedCancellationException(h);
1845 <        f.complete(v1);
1845 >        (!fFirst ? f : g).complete(v1);
1846  
2227 –        checkCancelled(g);
1847          assertEquals(0, r.invocationCount);
1848 <        checkCompletedNormally(f, v1);
1848 >        checkCompletedNormally(!fFirst ? f : g, v1);
1849 >        checkCancelled(fFirst ? f : g);
1850          checkCompletedWithWrappedCancellationException(h);
1851      }}
1852  
1853 <    public void testApplyToEither_sourceCancelled3() {
1853 >    public void testApplyToEither_sourceCancelled2() {
1854          for (ExecutionMode m : ExecutionMode.values())
1855          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1856 +        for (boolean reverseArgs : new boolean[] { true, false })
1857 +        for (boolean fFirst : new boolean[] { true, false })
1858          for (Integer v1 : new Integer[] { 1, null })
1859      {
1860          final CompletableFuture<Integer> f = new CompletableFuture<>();
1861          final CompletableFuture<Integer> g = new CompletableFuture<>();
1862 <        final IncFunction r = new IncFunction();
1862 >        final IncFunction r1 = new IncFunction(m);
1863 >        final IncFunction r2 = new IncFunction(m);
1864 >        final CFException ex = new CFException();
1865 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1866 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1867  
1868 <        assertTrue(g.cancel(mayInterruptIfRunning));
1869 <        f.complete(v1);
1870 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1868 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1869 >        if (fFirst) {
1870 >            f.complete(v1);
1871 >            assertTrue(g.cancel(mayInterruptIfRunning));
1872 >        } else {
1873 >            assertTrue(g.cancel(mayInterruptIfRunning));
1874 >            f.complete(v1);
1875 >        }
1876 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1877  
1878          // unspecified behavior
2247 –        Integer v;
1879          try {
1880 <            assertEquals(inc(v1), h.join());
1881 <            assertEquals(1, r.invocationCount);
1880 >            assertEquals(inc(v1), h1.join());
1881 >            assertEquals(1, r1.invocationCount);
1882          } catch (CompletionException ok) {
1883 <            checkCompletedWithWrappedCancellationException(h);
1884 <            assertEquals(0, r.invocationCount);
1883 >            checkCompletedWithWrappedCancellationException(h1);
1884 >            assertEquals(0, r1.invocationCount);
1885          }
1886  
2256 –        checkCancelled(g);
2257 –        checkCompletedNormally(f, v1);
2258 –    }}
2259 –
2260 –    public void testApplyToEither_sourceCancelled4() {
2261 –        for (ExecutionMode m : ExecutionMode.values())
2262 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2263 –        for (Integer v1 : new Integer[] { 1, null })
2264 –    {
2265 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2266 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2267 –        final IncFunction r = new IncFunction();
2268 –
2269 –        assertTrue(f.cancel(mayInterruptIfRunning));
2270 –        g.complete(v1);
2271 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2272 –
2273 –        // unspecified behavior
2274 –        Integer v;
1887          try {
1888 <            assertEquals(inc(v1), h.join());
1889 <            assertEquals(1, r.invocationCount);
1888 >            assertEquals(inc(v1), h2.join());
1889 >            assertEquals(1, r2.invocationCount);
1890          } catch (CompletionException ok) {
1891 <            checkCompletedWithWrappedCancellationException(h);
1892 <            assertEquals(0, r.invocationCount);
1891 >            checkCompletedWithWrappedCancellationException(h2);
1892 >            assertEquals(0, r2.invocationCount);
1893          }
1894  
1895 <        checkCancelled(f);
1896 <        checkCompletedNormally(g, v1);
1895 >        checkCancelled(g);
1896 >        checkCompletedNormally(f, v1);
1897      }}
1898  
1899      /**
# Line 2460 | Line 2072 | public class CompletableFutureTest exten
2072      {
2073          final CompletableFuture<Integer> f = new CompletableFuture<>();
2074          final CompletableFuture<Integer> g = new CompletableFuture<>();
2075 <        final FailingConsumer r = new FailingConsumer();
2075 >        final FailingConsumer r = new FailingConsumer(m);
2076          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2077  
2078          f.complete(v1);
# Line 2477 | Line 2089 | public class CompletableFutureTest exten
2089      {
2090          final CompletableFuture<Integer> f = new CompletableFuture<>();
2091          final CompletableFuture<Integer> g = new CompletableFuture<>();
2092 <        final FailingConsumer r = new FailingConsumer();
2092 >        final FailingConsumer r = new FailingConsumer(m);
2093          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2094  
2095          g.complete(v2);
# Line 2597 | Line 2209 | public class CompletableFutureTest exten
2209      {
2210          final CompletableFuture<Integer> f = new CompletableFuture<>();
2211          final CompletableFuture<Integer> g = new CompletableFuture<>();
2212 <        final Noop r = new Noop();
2212 >        final Noop r = new Noop(m);
2213          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2214  
2215          f.complete(v1);
# Line 2618 | Line 2230 | public class CompletableFutureTest exten
2230      {
2231          final CompletableFuture<Integer> f = new CompletableFuture<>();
2232          final CompletableFuture<Integer> g = new CompletableFuture<>();
2233 <        final Noop r = new Noop();
2233 >        final Noop r = new Noop(m);
2234          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2235  
2236          g.complete(v2);
# Line 2639 | Line 2251 | public class CompletableFutureTest exten
2251      {
2252          final CompletableFuture<Integer> f = new CompletableFuture<>();
2253          final CompletableFuture<Integer> g = new CompletableFuture<>();
2254 <        final Noop r = new Noop();
2254 >        final Noop r = new Noop(m);
2255  
2256          f.complete(v1);
2257          g.complete(v2);
# Line 2661 | Line 2273 | public class CompletableFutureTest exten
2273      {
2274          final CompletableFuture<Integer> f = new CompletableFuture<>();
2275          final CompletableFuture<Integer> g = new CompletableFuture<>();
2276 <        final Noop r = new Noop();
2276 >        final Noop r = new Noop(m);
2277          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2278          final CFException ex = new CFException();
2279  
# Line 2681 | Line 2293 | public class CompletableFutureTest exten
2293      {
2294          final CompletableFuture<Integer> f = new CompletableFuture<>();
2295          final CompletableFuture<Integer> g = new CompletableFuture<>();
2296 <        final Noop r = new Noop();
2296 >        final Noop r = new Noop(m);
2297          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2298          final CFException ex = new CFException();
2299  
# Line 2701 | Line 2313 | public class CompletableFutureTest exten
2313      {
2314          final CompletableFuture<Integer> f = new CompletableFuture<>();
2315          final CompletableFuture<Integer> g = new CompletableFuture<>();
2316 <        final Noop r = new Noop();
2316 >        final Noop r = new Noop(m);
2317          final CFException ex = new CFException();
2318  
2319          g.completeExceptionally(ex);
# Line 2728 | Line 2340 | public class CompletableFutureTest exten
2340      {
2341          final CompletableFuture<Integer> f = new CompletableFuture<>();
2342          final CompletableFuture<Integer> g = new CompletableFuture<>();
2343 <        final Noop r = new Noop();
2343 >        final Noop r = new Noop(m);
2344          final CFException ex = new CFException();
2345  
2346          f.completeExceptionally(ex);
# Line 2759 | Line 2371 | public class CompletableFutureTest exten
2371      {
2372          final CompletableFuture<Integer> f = new CompletableFuture<>();
2373          final CompletableFuture<Integer> g = new CompletableFuture<>();
2374 <        final FailingNoop r = new FailingNoop();
2374 >        final FailingRunnable r = new FailingRunnable(m);
2375          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2376  
2377          f.complete(v1);
# Line 2776 | Line 2388 | public class CompletableFutureTest exten
2388      {
2389          final CompletableFuture<Integer> f = new CompletableFuture<>();
2390          final CompletableFuture<Integer> g = new CompletableFuture<>();
2391 <        final FailingNoop r = new FailingNoop();
2391 >        final FailingRunnable r = new FailingRunnable(m);
2392          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2393  
2394          g.complete(v2);
# Line 2796 | Line 2408 | public class CompletableFutureTest exten
2408      {
2409          final CompletableFuture<Integer> f = new CompletableFuture<>();
2410          final CompletableFuture<Integer> g = new CompletableFuture<>();
2411 <        final Noop r = new Noop();
2411 >        final Noop r = new Noop(m);
2412          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2413  
2414          assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2816 | Line 2428 | public class CompletableFutureTest exten
2428      {
2429          final CompletableFuture<Integer> f = new CompletableFuture<>();
2430          final CompletableFuture<Integer> g = new CompletableFuture<>();
2431 <        final Noop r = new Noop();
2431 >        final Noop r = new Noop(m);
2432          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2433  
2434          assertTrue(g.cancel(mayInterruptIfRunning));
# Line 2836 | Line 2448 | public class CompletableFutureTest exten
2448      {
2449          final CompletableFuture<Integer> f = new CompletableFuture<>();
2450          final CompletableFuture<Integer> g = new CompletableFuture<>();
2451 <        final Noop r = new Noop();
2451 >        final Noop r = new Noop(m);
2452  
2453          assertTrue(g.cancel(mayInterruptIfRunning));
2454          f.complete(v1);
# Line 2863 | Line 2475 | public class CompletableFutureTest exten
2475      {
2476          final CompletableFuture<Integer> f = new CompletableFuture<>();
2477          final CompletableFuture<Integer> g = new CompletableFuture<>();
2478 <        final Noop r = new Noop();
2478 >        final Noop r = new Noop(m);
2479  
2480          assertTrue(f.cancel(mayInterruptIfRunning));
2481          g.complete(v1);
# Line 2892 | Line 2504 | public class CompletableFutureTest exten
2504          for (Integer v1 : new Integer[] { 1, null })
2505      {
2506          final CompletableFuture<Integer> f = new CompletableFuture<>();
2507 <        final CompletableFutureInc r = new CompletableFutureInc();
2507 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2508          if (!createIncomplete) f.complete(v1);
2509 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2509 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2510          if (createIncomplete) f.complete(v1);
2511  
2512          checkCompletedNormally(g, inc(v1));
# Line 2911 | Line 2523 | public class CompletableFutureTest exten
2523          for (boolean createIncomplete : new boolean[] { true, false })
2524      {
2525          final CFException ex = new CFException();
2526 <        final CompletableFutureInc r = new CompletableFutureInc();
2526 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2527          final CompletableFuture<Integer> f = new CompletableFuture<>();
2528          if (!createIncomplete) f.completeExceptionally(ex);
2529 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2529 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2530          if (createIncomplete) f.completeExceptionally(ex);
2531  
2532          checkCompletedWithWrappedCFException(g, ex);
# Line 2932 | Line 2544 | public class CompletableFutureTest exten
2544      {
2545          final CompletableFuture<Integer> f = new CompletableFuture<>();
2546          final FailingCompletableFutureFunction r
2547 <            = new FailingCompletableFutureFunction();
2547 >            = new FailingCompletableFutureFunction(m);
2548          if (!createIncomplete) f.complete(v1);
2549 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2549 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2550          if (createIncomplete) f.complete(v1);
2551  
2552          checkCompletedWithWrappedCFException(g);
# Line 2950 | Line 2562 | public class CompletableFutureTest exten
2562          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2563      {
2564          final CompletableFuture<Integer> f = new CompletableFuture<>();
2565 <        final CompletableFutureInc r = new CompletableFutureInc();
2565 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2566          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2567 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2568 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2567 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2568 >        if (createIncomplete) {
2569 >            checkIncomplete(g);
2570 >            assertTrue(f.cancel(mayInterruptIfRunning));
2571 >        }
2572  
2573          checkCompletedWithWrappedCancellationException(g);
2574          checkCancelled(f);
2575      }}
2576  
2962 –    // asyncs
2963 –
2964 –    /**
2965 –     * thenAcceptAsync result completes normally after normal
2966 –     * completion of source
2967 –     */
2968 –    public void testThenAcceptAsync() {
2969 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2970 –        IncAction r = new IncAction();
2971 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2972 –        f.complete(one);
2973 –        checkCompletedNormally(g, null);
2974 –        assertEquals(r.value, (Integer) 2);
2975 –    }
2976 –
2977 –    /**
2978 –     * thenAcceptAsync result completes exceptionally after exceptional
2979 –     * completion of source
2980 –     */
2981 –    public void testThenAcceptAsync2() {
2982 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2983 –        IncAction r = new IncAction();
2984 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2985 –        f.completeExceptionally(new CFException());
2986 –        checkCompletedWithWrappedCFException(g);
2987 –    }
2988 –
2989 –    /**
2990 –     * thenAcceptAsync result completes exceptionally if action does
2991 –     */
2992 –    public void testThenAcceptAsync3() {
2993 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2994 –        FailingConsumer r = new FailingConsumer();
2995 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2996 –        f.complete(null);
2997 –        checkCompletedWithWrappedCFException(g);
2998 –    }
2999 –
3000 –    /**
3001 –     * thenAcceptAsync result completes exceptionally if source cancelled
3002 –     */
3003 –    public void testThenAcceptAsync4() {
3004 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3005 –        IncAction r = new IncAction();
3006 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3007 –        assertTrue(f.cancel(true));
3008 –        checkCompletedWithWrappedCancellationException(g);
3009 –    }
3010 –
3011 –    // async with explicit executors
3012 –
3013 –    /**
3014 –     * thenAcceptAsync result completes normally after normal
3015 –     * completion of source
3016 –     */
3017 –    public void testThenAcceptAsyncE() {
3018 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3019 –        IncAction r = new IncAction();
3020 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3021 –        f.complete(one);
3022 –        checkCompletedNormally(g, null);
3023 –        assertEquals(r.value, (Integer) 2);
3024 –    }
3025 –
3026 –    /**
3027 –     * thenAcceptAsync result completes exceptionally after exceptional
3028 –     * completion of source
3029 –     */
3030 –    public void testThenAcceptAsync2E() {
3031 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3032 –        IncAction r = new IncAction();
3033 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3034 –        f.completeExceptionally(new CFException());
3035 –        checkCompletedWithWrappedCFException(g);
3036 –    }
3037 –
3038 –    /**
3039 –     * thenAcceptAsync result completes exceptionally if action does
3040 –     */
3041 –    public void testThenAcceptAsync3E() {
3042 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3043 –        FailingConsumer r = new FailingConsumer();
3044 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3045 –        f.complete(null);
3046 –        checkCompletedWithWrappedCFException(g);
3047 –    }
3048 –
3049 –    /**
3050 –     * thenAcceptAsync result completes exceptionally if source cancelled
3051 –     */
3052 –    public void testThenAcceptAsync4E() {
3053 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3054 –        IncAction r = new IncAction();
3055 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3056 –        assertTrue(f.cancel(true));
3057 –        checkCompletedWithWrappedCancellationException(g);
3058 –    }
3059 –
2577      // other static methods
2578  
2579      /**
# Line 3219 | Line 2736 | public class CompletableFutureTest exten
2736  
2737              () -> f.thenCompose(null),
2738              () -> f.thenComposeAsync(null),
2739 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2739 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2740              () -> f.thenComposeAsync(null, exec),
2741  
2742              () -> f.exceptionally(null),

Diff Legend

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