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.48 by jsr166, Mon Jun 2 19:07:14 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 1050 | Line 1118 | public class CompletableFutureTest exten
1118      /**
1119       * thenApply result completes normally after normal completion of source
1120       */
1121 <    public void testThenApply() {
1054 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1055 <        CompletableFuture<Integer> g = f.thenApply(inc);
1056 <        f.complete(one);
1057 <        checkCompletedNormally(g, two);
1058 <    }
1059 <
1060 <    /**
1061 <     * thenApply result completes exceptionally after exceptional
1062 <     * completion of source
1063 <     */
1064 <    public void testThenApply2() {
1065 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1066 <        CompletableFuture<Integer> g = f.thenApply(inc);
1067 <        f.completeExceptionally(new CFException());
1068 <        checkCompletedWithWrappedCFException(g);
1069 <    }
1070 <
1071 <    /**
1072 <     * thenApply result completes exceptionally if action does
1073 <     */
1074 <    public void testThenApply3() {
1075 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1076 <        CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
1077 <        f.complete(one);
1078 <        checkCompletedWithWrappedCFException(g);
1079 <    }
1080 <
1081 <    /**
1082 <     * thenApply result completes exceptionally if source cancelled
1083 <     */
1084 <    public void testThenApply4() {
1085 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1086 <        CompletableFuture<Integer> g = f.thenApply(inc);
1087 <        assertTrue(f.cancel(true));
1088 <        checkCompletedWithWrappedCancellationException(g);
1089 <    }
1090 <
1091 <    /**
1092 <     * thenAccept result completes normally after normal completion of source
1093 <     */
1094 <    public void testThenAccept() {
1095 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1096 <        IncAction r = new IncAction();
1097 <        CompletableFuture<Void> g = f.thenAccept(r);
1098 <        f.complete(one);
1099 <        checkCompletedNormally(g, null);
1100 <        assertEquals(r.value, (Integer) 2);
1101 <    }
1102 <
1103 <    /**
1104 <     * thenAccept result completes exceptionally after exceptional
1105 <     * completion of source
1106 <     */
1107 <    public void testThenAccept2() {
1108 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1109 <        IncAction r = new IncAction();
1110 <        CompletableFuture<Void> g = f.thenAccept(r);
1111 <        f.completeExceptionally(new CFException());
1112 <        checkCompletedWithWrappedCFException(g);
1113 <    }
1114 <
1115 <    /**
1116 <     * thenAccept result completes exceptionally if action does
1117 <     */
1118 <    public void testThenAccept3() {
1119 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1120 <        FailingConsumer r = new FailingConsumer();
1121 <        CompletableFuture<Void> g = f.thenAccept(r);
1122 <        f.complete(one);
1123 <        checkCompletedWithWrappedCFException(g);
1124 <        assertEquals(1, r.invocationCount);
1125 <    }
1126 <
1127 <    /**
1128 <     * thenAccept result completes exceptionally if source cancelled
1129 <     */
1130 <    public void testThenAccept4() {
1131 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1132 <        IncAction r = new IncAction();
1133 <        CompletableFuture<Void> g = f.thenAccept(r);
1134 <        assertTrue(f.cancel(true));
1135 <        checkCompletedWithWrappedCancellationException(g);
1136 <    }
1137 <
1138 <    /**
1139 <     * thenCombine result completes normally after normal completion
1140 <     * of sources
1141 <     */
1142 <    public void testThenCombine_normalCompletion1() {
1143 <        for (boolean createIncomplete : new boolean[] { true, false })
1144 <        for (boolean fFirst : new boolean[] { true, false })
1121 >    public void testThenApply_normalCompletion() {
1122          for (ExecutionMode m : ExecutionMode.values())
1123 +        for (boolean createIncomplete : new boolean[] { true, false })
1124          for (Integer v1 : new Integer[] { 1, null })
1147 –        for (Integer v2 : new Integer[] { 2, null })
1125      {
1126          final CompletableFuture<Integer> f = new CompletableFuture<>();
1127 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1128 <        final SubtractFunction r = new SubtractFunction();
1129 <        CompletableFuture<Integer> h = null;
1130 <        if (createIncomplete) h = m.thenCombine(f, g, r);
1131 <
1155 <        if (fFirst)
1156 <            f.complete(v1);
1157 <        else
1158 <            g.complete(v2);
1159 <        if (createIncomplete) checkIncomplete(h);
1160 <        assertEquals(0, r.invocationCount);
1161 <        if (!fFirst)
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) {
1131 >            checkIncomplete(g);
1132              f.complete(v1);
1133 <        else
1164 <            g.complete(v2);
1165 <        if (!createIncomplete) h = m.thenCombine(f, g, r);
1133 >        }
1134  
1135 <        checkCompletedNormally(h, subtract(v1, v2));
1135 >        checkCompletedNormally(g, inc(v1));
1136          checkCompletedNormally(f, v1);
1169 –        checkCompletedNormally(g, v2);
1137          assertEquals(1, r.invocationCount);
1138      }}
1139  
1140      /**
1141 <     * thenCombine result completes exceptionally after exceptional
1142 <     * completion of either source
1141 >     * thenApply result completes exceptionally after exceptional
1142 >     * completion of source
1143       */
1144 <    public void testThenCombine_exceptionalCompletion1() {
1144 >    public void testThenApply_exceptionalCompletion() {
1145          for (ExecutionMode m : ExecutionMode.values())
1146 <        for (Integer v1 : new Integer[] { 1, null })
1146 >        for (boolean createIncomplete : new boolean[] { true, false })
1147      {
1181 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1182 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1183 –        final SubtractFunction r = new SubtractFunction();
1184 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1148          final CFException ex = new CFException();
1149 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
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) {
1154 +            checkIncomplete(g);
1155 +            f.completeExceptionally(ex);
1156 +        }
1157  
1158 <        f.completeExceptionally(ex);
1188 <        checkIncomplete(h);
1189 <        g.complete(v1);
1190 <
1191 <        checkCompletedWithWrappedCFException(h, ex);
1158 >        checkCompletedWithWrappedCFException(g, ex);
1159          checkCompletedWithWrappedCFException(f, ex);
1160          assertEquals(0, r.invocationCount);
1194 –        checkCompletedNormally(g, v1);
1161      }}
1162  
1163 <    public void testThenCombine_exceptionalCompletion2() {
1163 >    /**
1164 >     * thenApply result completes exceptionally if source cancelled
1165 >     */
1166 >    public void testThenApply_sourceCancelled() {
1167          for (ExecutionMode m : ExecutionMode.values())
1168 <        for (Integer v1 : new Integer[] { 1, null })
1168 >        for (boolean createIncomplete : new boolean[] { true, false })
1169 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1170      {
1171          final CompletableFuture<Integer> f = new CompletableFuture<>();
1172 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1173 <        final SubtractFunction r = new SubtractFunction();
1174 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1175 <        final CFException ex = new CFException();
1176 <
1177 <        g.completeExceptionally(ex);
1178 <        checkIncomplete(h);
1209 <        f.complete(v1);
1172 >        final IncFunction r = new IncFunction(m);
1173 >        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 <        checkCompletedWithWrappedCFException(h, ex);
1181 <        checkCompletedWithWrappedCFException(g, ex);
1180 >        checkCompletedWithWrappedCancellationException(g);
1181 >        checkCancelled(f);
1182          assertEquals(0, r.invocationCount);
1214 –        checkCompletedNormally(f, v1);
1183      }}
1184  
1185 <    public void testThenCombine_exceptionalCompletion3() {
1185 >    /**
1186 >     * thenApply result completes exceptionally if action does
1187 >     */
1188 >    public void testThenApply_actionFailed() {
1189          for (ExecutionMode m : ExecutionMode.values())
1190 +        for (boolean createIncomplete : new boolean[] { true, false })
1191          for (Integer v1 : new Integer[] { 1, null })
1192      {
1193          final CompletableFuture<Integer> f = new CompletableFuture<>();
1194 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1195 <        final SubtractFunction r = new SubtractFunction();
1196 <        final CFException ex = new CFException();
1197 <
1198 <        g.completeExceptionally(ex);
1199 <        f.complete(v1);
1200 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1194 >        final FailingFunction r = new FailingFunction(m);
1195 >        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(h, ex);
1231 <        checkCompletedWithWrappedCFException(g, ex);
1232 <        assertEquals(0, r.invocationCount);
1202 >        checkCompletedWithWrappedCFException(g);
1203          checkCompletedNormally(f, v1);
1204      }}
1205  
1206 <    public void testThenCombine_exceptionalCompletion4() {
1206 >    /**
1207 >     * thenAccept result completes normally after normal completion of source
1208 >     */
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 })
1213      {
1214          final CompletableFuture<Integer> f = new CompletableFuture<>();
1215 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1216 <        final SubtractFunction r = new SubtractFunction();
1217 <        final CFException ex = new CFException();
1218 <
1219 <        f.completeExceptionally(ex);
1220 <        g.complete(v1);
1221 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
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 >        }
1222  
1223 <        checkCompletedWithWrappedCFException(h, ex);
1224 <        checkCompletedWithWrappedCFException(f, ex);
1225 <        assertEquals(0, r.invocationCount);
1226 <        checkCompletedNormally(g, v1);
1223 >        checkCompletedNormally(g, null);
1224 >        checkCompletedNormally(f, v1);
1225 >        assertEquals(1, r.invocationCount);
1226 >        assertEquals(inc(v1), r.value);
1227      }}
1228  
1229      /**
1230 <     * thenCombine result completes exceptionally if action does
1230 >     * thenAccept result completes exceptionally after exceptional
1231 >     * completion of source
1232       */
1233 <    public void testThenCombine_actionFailed1() {
1233 >    public void testThenAccept_exceptionalCompletion() {
1234          for (ExecutionMode m : ExecutionMode.values())
1235 <        for (Integer v1 : new Integer[] { 1, null })
1261 <        for (Integer v2 : new Integer[] { 2, null })
1235 >        for (boolean createIncomplete : new boolean[] { true, false })
1236      {
1237 +        final CFException ex = new CFException();
1238          final CompletableFuture<Integer> f = new CompletableFuture<>();
1239 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1240 <        final FailingBiFunction r = new FailingBiFunction();
1241 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1242 <
1243 <        f.complete(v1);
1244 <        checkIncomplete(h);
1245 <        g.complete(v2);
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  
1247 <        checkCompletedWithWrappedCFException(h);
1248 <        checkCompletedNormally(f, v1);
1249 <        checkCompletedNormally(g, v2);
1247 >        checkCompletedWithWrappedCFException(g, ex);
1248 >        checkCompletedWithWrappedCFException(f, ex);
1249 >        assertEquals(0, r.invocationCount);
1250      }}
1251  
1252 <    public void testThenCombine_actionFailed2() {
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 })
1280 –        for (Integer v2 : new Integer[] { 2, null })
1259      {
1260          final CompletableFuture<Integer> f = new CompletableFuture<>();
1261 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1262 <        final FailingBiFunction r = new FailingBiFunction();
1263 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1264 <
1265 <        g.complete(v2);
1266 <        checkIncomplete(h);
1267 <        f.complete(v1);
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);
1269 >        checkCompletedWithWrappedCFException(g);
1270          checkCompletedNormally(f, v1);
1293 –        checkCompletedNormally(g, v2);
1271      }}
1272  
1273      /**
1274 <     * thenCombine result completes exceptionally if either source cancelled
1274 >     * thenAccept result completes exceptionally if source cancelled
1275       */
1276 <    public void testThenCombine_sourceCancelled1() {
1276 >    public void testThenAccept_sourceCancelled() {
1277          for (ExecutionMode m : ExecutionMode.values())
1278 +        for (boolean createIncomplete : new boolean[] { true, false })
1279          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1302 –        for (Integer v1 : new Integer[] { 1, null })
1280      {
1281          final CompletableFuture<Integer> f = new CompletableFuture<>();
1282 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1283 <        final SubtractFunction r = new SubtractFunction();
1284 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1285 <
1286 <        assertTrue(f.cancel(mayInterruptIfRunning));
1287 <        checkIncomplete(h);
1288 <        g.complete(v1);
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 <        checkCompletedWithWrappedCancellationException(h);
1290 >        checkCompletedWithWrappedCancellationException(g);
1291          checkCancelled(f);
1292          assertEquals(0, r.invocationCount);
1316 –        checkCompletedNormally(g, v1);
1317 –    }}
1318 –
1319 –    public void testThenCombine_sourceCancelled2() {
1320 –        for (ExecutionMode m : ExecutionMode.values())
1321 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1322 –        for (Integer v1 : new Integer[] { 1, null })
1323 –    {
1324 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1325 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1326 –        final SubtractFunction r = new SubtractFunction();
1327 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1328 –
1329 –        assertTrue(g.cancel(mayInterruptIfRunning));
1330 –        checkIncomplete(h);
1331 –        f.complete(v1);
1332 –
1333 –        checkCompletedWithWrappedCancellationException(h);
1334 –        checkCancelled(g);
1335 –        assertEquals(0, r.invocationCount);
1336 –        checkCompletedNormally(f, v1);
1293      }}
1294  
1295 <    public void testThenCombine_sourceCancelled3() {
1295 >    /**
1296 >     * thenCombine result completes normally after normal completion
1297 >     * of sources
1298 >     */
1299 >    public void testThenCombine_normalCompletion() {
1300          for (ExecutionMode m : ExecutionMode.values())
1301 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
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 SubtractFunction r = new SubtractFunction();
1308 >        final SubtractFunction r = new SubtractFunction(m);
1309  
1310 <        assertTrue(g.cancel(mayInterruptIfRunning));
1311 <        f.complete(v1);
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 <        checkCompletedWithWrappedCancellationException(h);
1353 <        checkCancelled(g);
1354 <        assertEquals(0, r.invocationCount);
1320 >        checkCompletedNormally(h, subtract(v1, v2));
1321          checkCompletedNormally(f, v1);
1322 +        checkCompletedNormally(g, v2);
1323 +        assertEquals(1, r.invocationCount);
1324      }}
1325  
1326 <    public void testThenCombine_sourceCancelled4() {
1326 >    /**
1327 >     * thenCombine result completes exceptionally after exceptional
1328 >     * completion of either source
1329 >     */
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();
1338 >        final CFException ex = new CFException();
1339 >        final SubtractFunction r = new SubtractFunction(m);
1340  
1341 <        assertTrue(f.cancel(mayInterruptIfRunning));
1342 <        g.complete(v1);
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 <        checkCompletedWithWrappedCancellationException(h);
1372 <        checkCancelled(f);
1350 >        checkCompletedWithWrappedCFException(h, ex);
1351          assertEquals(0, r.invocationCount);
1352 <        checkCompletedNormally(g, v1);
1352 >        checkCompletedNormally(fFirst ? f : g, v1);
1353 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1354      }}
1355  
1356      /**
1357 <     * thenAcceptBoth result completes normally after normal
1379 <     * completion of sources
1357 >     * thenCombine result completes exceptionally if action does
1358       */
1359 <    public void testThenAcceptBoth_normalCompletion1() {
1382 <        for (ExecutionMode m : ExecutionMode.values())
1383 <        for (Integer v1 : new Integer[] { 1, null })
1384 <        for (Integer v2 : new Integer[] { 2, null })
1385 <    {
1386 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1387 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1388 <        final SubtractAction r = new SubtractAction();
1389 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1390 <
1391 <        f.complete(v1);
1392 <        checkIncomplete(h);
1393 <        assertEquals(0, r.invocationCount);
1394 <        g.complete(v2);
1395 <
1396 <        checkCompletedNormally(h, null);
1397 <        assertEquals(subtract(v1, v2), r.value);
1398 <        checkCompletedNormally(f, v1);
1399 <        checkCompletedNormally(g, v2);
1400 <    }}
1401 <
1402 <    public void testThenAcceptBoth_normalCompletion2() {
1359 >    public void testThenCombine_actionFailed() {
1360          for (ExecutionMode m : ExecutionMode.values())
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 SubtractAction r = new SubtractAction();
1368 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1367 >        final FailingBiFunction r = new FailingBiFunction(m);
1368 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1369  
1370 <        g.complete(v2);
1371 <        checkIncomplete(h);
1372 <        assertEquals(0, r.invocationCount);
1373 <        f.complete(v1);
1370 >        if (fFirst) {
1371 >            f.complete(v1);
1372 >            g.complete(v2);
1373 >        } else {
1374 >            g.complete(v2);
1375 >            f.complete(v1);
1376 >        }
1377  
1378 <        checkCompletedNormally(h, null);
1418 <        assertEquals(subtract(v1, v2), r.value);
1378 >        checkCompletedWithWrappedCFException(h);
1379          checkCompletedNormally(f, v1);
1380          checkCompletedNormally(g, v2);
1381      }}
1382  
1383 <    public void testThenAcceptBoth_normalCompletion3() {
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 })
1426 –        for (Integer v2 : new Integer[] { 2, null })
1392      {
1393          final CompletableFuture<Integer> f = new CompletableFuture<>();
1394          final CompletableFuture<Integer> g = new CompletableFuture<>();
1395 <        final SubtractAction r = new SubtractAction();
1395 >        final SubtractFunction r = new SubtractFunction(m);
1396  
1397 <        g.complete(v2);
1398 <        f.complete(v1);
1399 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
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 <        checkCompletedNormally(h, null);
1407 <        assertEquals(subtract(v1, v2), r.value);
1408 <        checkCompletedNormally(f, v1);
1409 <        checkCompletedNormally(g, v2);
1406 >        checkCompletedWithWrappedCancellationException(h);
1407 >        checkCancelled(!fFirst ? f : g);
1408 >        assertEquals(0, r.invocationCount);
1409 >        checkCompletedNormally(fFirst ? f : g, v1);
1410      }}
1411  
1412 <    public void testThenAcceptBoth_normalCompletion4() {
1412 >    /**
1413 >     * thenAcceptBoth result completes normally after normal
1414 >     * completion of sources
1415 >     */
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 1462 | Line 1444 | public class CompletableFutureTest exten
1444       * thenAcceptBoth result completes exceptionally after exceptional
1445       * completion of either source
1446       */
1447 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1466 <        for (ExecutionMode m : ExecutionMode.values())
1467 <        for (Integer v1 : new Integer[] { 1, null })
1468 <    {
1469 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1470 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1471 <        final SubtractAction r = new SubtractAction();
1472 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1473 <        final CFException ex = new CFException();
1474 <
1475 <        f.completeExceptionally(ex);
1476 <        checkIncomplete(h);
1477 <        g.complete(v1);
1478 <
1479 <        checkCompletedWithWrappedCFException(h, ex);
1480 <        checkCompletedWithWrappedCFException(f, ex);
1481 <        assertEquals(0, r.invocationCount);
1482 <        checkCompletedNormally(g, v1);
1483 <    }}
1484 <
1485 <    public void testThenAcceptBoth_exceptionalCompletion2() {
1486 <        for (ExecutionMode m : ExecutionMode.values())
1487 <        for (Integer v1 : new Integer[] { 1, null })
1488 <    {
1489 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1490 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1491 <        final SubtractAction r = new SubtractAction();
1492 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1493 <        final CFException ex = new CFException();
1494 <
1495 <        g.completeExceptionally(ex);
1496 <        checkIncomplete(h);
1497 <        f.complete(v1);
1498 <
1499 <        checkCompletedWithWrappedCFException(h, ex);
1500 <        checkCompletedWithWrappedCFException(g, ex);
1501 <        assertEquals(0, r.invocationCount);
1502 <        checkCompletedNormally(f, v1);
1503 <    }}
1504 <
1505 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1506 <        for (ExecutionMode m : ExecutionMode.values())
1507 <        for (Integer v1 : new Integer[] { 1, null })
1508 <    {
1509 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1510 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1511 <        final SubtractAction r = new SubtractAction();
1512 <        final CFException ex = new CFException();
1513 <
1514 <        g.completeExceptionally(ex);
1515 <        f.complete(v1);
1516 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1517 <
1518 <        checkCompletedWithWrappedCFException(h, ex);
1519 <        checkCompletedWithWrappedCFException(g, ex);
1520 <        assertEquals(0, r.invocationCount);
1521 <        checkCompletedNormally(f, v1);
1522 <    }}
1523 <
1524 <    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<>();
1530 –        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);
1538 –        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() {
1547 <        for (ExecutionMode m : ExecutionMode.values())
1548 <        for (Integer v1 : new Integer[] { 1, null })
1549 <        for (Integer v2 : new Integer[] { 2, null })
1550 <    {
1551 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1552 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1553 <        final FailingBiConsumer r = new FailingBiConsumer();
1554 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1555 <
1556 <        f.complete(v1);
1557 <        checkIncomplete(h);
1558 <        g.complete(v2);
1559 <
1560 <        checkCompletedWithWrappedCFException(h);
1561 <        checkCompletedNormally(f, v1);
1562 <        checkCompletedNormally(g, v2);
1563 <    }}
1564 <
1565 <    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 1584 | Line 1500 | public class CompletableFutureTest exten
1500      /**
1501       * thenAcceptBoth result completes exceptionally if either source cancelled
1502       */
1503 <    public void testThenAcceptBoth_sourceCancelled1() {
1588 <        for (ExecutionMode m : ExecutionMode.values())
1589 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1590 <        for (Integer v1 : new Integer[] { 1, null })
1591 <    {
1592 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1593 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1594 <        final SubtractAction r = new SubtractAction();
1595 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1596 <
1597 <        assertTrue(f.cancel(mayInterruptIfRunning));
1598 <        checkIncomplete(h);
1599 <        g.complete(v1);
1600 <
1601 <        checkCompletedWithWrappedCancellationException(h);
1602 <        checkCancelled(f);
1603 <        assertEquals(0, r.invocationCount);
1604 <        checkCompletedNormally(g, v1);
1605 <    }}
1606 <
1607 <    public void testThenAcceptBoth_sourceCancelled2() {
1608 <        for (ExecutionMode m : ExecutionMode.values())
1609 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1610 <        for (Integer v1 : new Integer[] { 1, null })
1611 <    {
1612 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1613 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1614 <        final SubtractAction r = new SubtractAction();
1615 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1616 <
1617 <        assertTrue(g.cancel(mayInterruptIfRunning));
1618 <        checkIncomplete(h);
1619 <        f.complete(v1);
1620 <
1621 <        checkCompletedWithWrappedCancellationException(h);
1622 <        checkCancelled(g);
1623 <        assertEquals(0, r.invocationCount);
1624 <        checkCompletedNormally(f, v1);
1625 <    }}
1626 <
1627 <    public void testThenAcceptBoth_sourceCancelled3() {
1628 <        for (ExecutionMode m : ExecutionMode.values())
1629 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1630 <        for (Integer v1 : new Integer[] { 1, null })
1631 <    {
1632 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1633 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1634 <        final SubtractAction r = new SubtractAction();
1635 <
1636 <        assertTrue(g.cancel(mayInterruptIfRunning));
1637 <        f.complete(v1);
1638 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1639 <
1640 <        checkCompletedWithWrappedCancellationException(h);
1641 <        checkCancelled(g);
1642 <        assertEquals(0, r.invocationCount);
1643 <        checkCompletedNormally(f, v1);
1644 <    }}
1645 <
1646 <    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() {
1670 <        for (ExecutionMode m : ExecutionMode.values())
1671 <        for (Integer v1 : new Integer[] { 1, null })
1672 <        for (Integer v2 : new Integer[] { 2, null })
1673 <    {
1674 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1675 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1676 <        final Noop r = new Noop();
1677 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1678 <
1679 <        f.complete(v1);
1680 <        checkIncomplete(h);
1681 <        assertEquals(0, r.invocationCount);
1682 <        g.complete(v2);
1683 <
1684 <        checkCompletedNormally(h, null);
1685 <        assertEquals(1, r.invocationCount);
1686 <        checkCompletedNormally(f, v1);
1687 <        checkCompletedNormally(g, v2);
1688 <    }}
1689 <
1690 <    public void testRunAfterBoth_normalCompletion2() {
1691 <        for (ExecutionMode m : ExecutionMode.values())
1692 <        for (Integer v1 : new Integer[] { 1, null })
1693 <        for (Integer v2 : new Integer[] { 2, null })
1694 <    {
1695 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1696 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1697 <        final Noop r = new Noop();
1698 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1699 <
1700 <        g.complete(v2);
1701 <        checkIncomplete(h);
1702 <        assertEquals(0, r.invocationCount);
1703 <        f.complete(v1);
1704 <
1705 <        checkCompletedNormally(h, null);
1706 <        assertEquals(1, r.invocationCount);
1707 <        checkCompletedNormally(f, v1);
1708 <        checkCompletedNormally(g, v2);
1709 <    }}
1710 <
1711 <    public void testRunAfterBoth_normalCompletion3() {
1712 <        for (ExecutionMode m : ExecutionMode.values())
1713 <        for (Integer v1 : new Integer[] { 1, null })
1714 <        for (Integer v2 : new Integer[] { 2, null })
1715 <    {
1716 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1717 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1718 <        final Noop r = new Noop();
1719 <
1720 <        g.complete(v2);
1721 <        f.complete(v1);
1722 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1723 <
1724 <        checkCompletedNormally(h, null);
1725 <        assertEquals(1, r.invocationCount);
1726 <        checkCompletedNormally(f, v1);
1727 <        checkCompletedNormally(g, v2);
1728 <    }}
1729 <
1730 <    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 1750 | Line 1561 | public class CompletableFutureTest exten
1561       * runAfterBoth result completes exceptionally after exceptional
1562       * completion of either source
1563       */
1564 <    public void testRunAfterBoth_exceptionalCompletion1() {
1754 <        for (ExecutionMode m : ExecutionMode.values())
1755 <        for (Integer v1 : new Integer[] { 1, null })
1756 <    {
1757 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1758 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1759 <        final Noop r = new Noop();
1760 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1761 <        final CFException ex = new CFException();
1762 <
1763 <        f.completeExceptionally(ex);
1764 <        checkIncomplete(h);
1765 <        g.complete(v1);
1766 <
1767 <        checkCompletedWithWrappedCFException(h, ex);
1768 <        checkCompletedWithWrappedCFException(f, ex);
1769 <        assertEquals(0, r.invocationCount);
1770 <        checkCompletedNormally(g, v1);
1771 <    }}
1772 <
1773 <    public void testRunAfterBoth_exceptionalCompletion2() {
1774 <        for (ExecutionMode m : ExecutionMode.values())
1775 <        for (Integer v1 : new Integer[] { 1, null })
1776 <    {
1777 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1778 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1779 <        final Noop r = new Noop();
1780 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1781 <        final CFException ex = new CFException();
1782 <
1783 <        g.completeExceptionally(ex);
1784 <        checkIncomplete(h);
1785 <        f.complete(v1);
1786 <
1787 <        checkCompletedWithWrappedCFException(h, ex);
1788 <        checkCompletedWithWrappedCFException(g, ex);
1789 <        assertEquals(0, r.invocationCount);
1790 <        checkCompletedNormally(f, v1);
1791 <    }}
1792 <
1793 <    public void testRunAfterBoth_exceptionalCompletion3() {
1794 <        for (ExecutionMode m : ExecutionMode.values())
1795 <        for (Integer v1 : new Integer[] { 1, null })
1796 <    {
1797 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1798 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1799 <        final Noop r = new Noop();
1800 <        final CFException ex = new CFException();
1801 <
1802 <        g.completeExceptionally(ex);
1803 <        f.complete(v1);
1804 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1805 <
1806 <        checkCompletedWithWrappedCFException(h, ex);
1807 <        checkCompletedWithWrappedCFException(g, ex);
1808 <        assertEquals(0, r.invocationCount);
1809 <        checkCompletedNormally(f, v1);
1810 <    }}
1811 <
1812 <    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<>();
1818 –        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);
1826 –        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() {
1835 <        for (ExecutionMode m : ExecutionMode.values())
1836 <        for (Integer v1 : new Integer[] { 1, null })
1837 <        for (Integer v2 : new Integer[] { 2, null })
1838 <    {
1839 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1840 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1841 <        final FailingNoop r = new FailingNoop();
1842 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1843 <
1844 <        f.complete(v1);
1845 <        checkIncomplete(h);
1846 <        g.complete(v2);
1847 <
1848 <        checkCompletedWithWrappedCFException(h);
1849 <        checkCompletedNormally(f, v1);
1850 <        checkCompletedNormally(g, v2);
1851 <    }}
1852 <
1853 <    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();
1861 <        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 1872 | Line 1619 | public class CompletableFutureTest exten
1619      /**
1620       * runAfterBoth result completes exceptionally if either source cancelled
1621       */
1622 <    public void testRunAfterBoth_sourceCancelled1() {
1876 <        for (ExecutionMode m : ExecutionMode.values())
1877 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1878 <        for (Integer v1 : new Integer[] { 1, null })
1879 <    {
1880 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1881 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1882 <        final Noop r = new Noop();
1883 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1884 <
1885 <        assertTrue(f.cancel(mayInterruptIfRunning));
1886 <        checkIncomplete(h);
1887 <        g.complete(v1);
1888 <
1889 <        checkCompletedWithWrappedCancellationException(h);
1890 <        checkCancelled(f);
1891 <        assertEquals(0, r.invocationCount);
1892 <        checkCompletedNormally(g, v1);
1893 <    }}
1894 <
1895 <    public void testRunAfterBoth_sourceCancelled2() {
1896 <        for (ExecutionMode m : ExecutionMode.values())
1897 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1898 <        for (Integer v1 : new Integer[] { 1, null })
1899 <    {
1900 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1901 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1902 <        final Noop r = new Noop();
1903 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1904 <
1905 <        assertTrue(g.cancel(mayInterruptIfRunning));
1906 <        checkIncomplete(h);
1907 <        f.complete(v1);
1908 <
1909 <        checkCompletedWithWrappedCancellationException(h);
1910 <        checkCancelled(g);
1911 <        assertEquals(0, r.invocationCount);
1912 <        checkCompletedNormally(f, v1);
1913 <    }}
1914 <
1915 <    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();
1923 <
1924 <        assertTrue(g.cancel(mayInterruptIfRunning));
1925 <        f.complete(v1);
1926 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1631 >        final Noop r = new Noop(m);
1632  
1928 –        checkCompletedWithWrappedCancellationException(h);
1929 –        checkCancelled(g);
1930 –        assertEquals(0, r.invocationCount);
1931 –        checkCompletedNormally(f, v1);
1932 –    }}
1933 –
1934 –    public void testRunAfterBoth_sourceCancelled4() {
1935 –        for (ExecutionMode m : ExecutionMode.values())
1936 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1937 –        for (Integer v1 : new Integer[] { 1, null })
1938 –    {
1939 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1940 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1941 –        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();
1965 <        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();
1984 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1688 >        final IncFunction r = new IncFunction(m);
1689  
1690 <        g.complete(v2);
1691 <        checkCompletedNormally(h, inc(v2));
1692 <        f.complete(v1);
1693 <
1694 <        checkCompletedNormally(f, v1);
1695 <        checkCompletedNormally(g, v2);
1696 <        checkCompletedNormally(h, inc(v2));
1993 <        }}
1994 <
1995 <    public void testApplyToEither_normalCompletion3() {
1996 <        for (ExecutionMode m : ExecutionMode.values())
1997 <        for (Integer v1 : new Integer[] { 1, null })
1998 <        for (Integer v2 : new Integer[] { 2, null })
1999 <    {
2000 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2001 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2002 <        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  
2004 –        f.complete(v1);
2005 –        g.complete(v2);
1698          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1699  
1700          checkCompletedNormally(f, v1);
# Line 2020 | 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<>();
2027 –        final IncFunction r = new IncFunction();
2028 –        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);
2032 <        checkCompletedWithWrappedCFException(h, ex);
2033 <        g.complete(v1);
2034 <
2035 <        assertEquals(0, r.invocationCount);
2036 <        checkCompletedNormally(g, v1);
2037 <        checkCompletedWithWrappedCFException(f, ex);
2038 <        checkCompletedWithWrappedCFException(h, ex);
2039 <    }}
2040 <
2041 <    public void testApplyToEither_exceptionalCompletion2() {
2042 <        for (ExecutionMode m : ExecutionMode.values())
2043 <        for (Integer v1 : new Integer[] { 1, null })
2044 <    {
2045 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2046 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2047 <        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  
2051 –        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
2075 –        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  
2084 –        checkCompletedWithWrappedCFException(g, ex);
2085 –        checkCompletedNormally(f, v1);
2086 –    }}
2087 –
2088 –    public void testApplyToEither_exceptionalCompletion4() {
2089 –        for (ExecutionMode m : ExecutionMode.values())
2090 –        for (Integer v1 : new Integer[] { 1, null })
2091 –    {
2092 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2093 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2094 –        final IncFunction r = new IncFunction();
2095 –        final CFException ex = new CFException();
2096 –
2097 –        f.completeExceptionally(ex);
2098 –        g.complete(v1);
2099 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2100 –
2101 –        // unspecified behavior
2102 –        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 2122 | 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 2139 | 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 2155 | 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();
2163 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2164 <
2165 <        assertTrue(f.cancel(mayInterruptIfRunning));
2166 <        checkCompletedWithWrappedCancellationException(h);
2167 <        g.complete(v1);
2168 <
2169 <        checkCancelled(f);
2170 <        assertEquals(0, r.invocationCount);
2171 <        checkCompletedNormally(g, v1);
2172 <        checkCompletedWithWrappedCancellationException(h);
2173 <    }}
1834 >        final IncFunction r = new IncFunction(m);
1835  
1836 <    public void testApplyToEither_sourceCancelled2() {
2176 <        for (ExecutionMode m : ExecutionMode.values())
2177 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2178 <        for (Integer v1 : new Integer[] { 1, null })
2179 <    {
2180 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2181 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2182 <        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  
2185 –        assertTrue(g.cancel(mayInterruptIfRunning));
1844          checkCompletedWithWrappedCancellationException(h);
1845 <        f.complete(v1);
1845 >        (!fFirst ? f : g).complete(v1);
1846  
2189 –        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
2209 –        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  
2218 –        checkCancelled(g);
2219 –        checkCompletedNormally(f, v1);
2220 –    }}
2221 –
2222 –    public void testApplyToEither_sourceCancelled4() {
2223 –        for (ExecutionMode m : ExecutionMode.values())
2224 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2225 –        for (Integer v1 : new Integer[] { 1, null })
2226 –    {
2227 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2228 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2229 –        final IncFunction r = new IncFunction();
2230 –
2231 –        assertTrue(f.cancel(mayInterruptIfRunning));
2232 –        g.complete(v1);
2233 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2234 –
2235 –        // unspecified behavior
2236 –        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 2422 | 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 2439 | 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 2559 | 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 2580 | 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 2601 | 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 2623 | 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 2643 | 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 2663 | 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 2690 | 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 2721 | 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 2738 | 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 2758 | 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 2778 | 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 2798 | 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 2825 | 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 2854 | 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 2873 | 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 2894 | 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 2912 | 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  
2924 –    // asyncs
2925 –
2926 –    /**
2927 –     * thenApplyAsync result completes normally after normal completion of source
2928 –     */
2929 –    public void testThenApplyAsync() {
2930 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2931 –        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2932 –        f.complete(one);
2933 –        checkCompletedNormally(g, two);
2934 –    }
2935 –
2936 –    /**
2937 –     * thenApplyAsync result completes exceptionally after exceptional
2938 –     * completion of source
2939 –     */
2940 –    public void testThenApplyAsync2() {
2941 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2942 –        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2943 –        f.completeExceptionally(new CFException());
2944 –        checkCompletedWithWrappedCFException(g);
2945 –    }
2946 –
2947 –    /**
2948 –     * thenApplyAsync result completes exceptionally if action does
2949 –     */
2950 –    public void testThenApplyAsync3() {
2951 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2952 –        FailingFunction r = new FailingFunction();
2953 –        CompletableFuture<Integer> g = f.thenApplyAsync(r);
2954 –        f.complete(null);
2955 –        checkCompletedWithWrappedCFException(g);
2956 –    }
2957 –
2958 –    /**
2959 –     * thenApplyAsync result completes exceptionally if source cancelled
2960 –     */
2961 –    public void testThenApplyAsync4() {
2962 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2963 –        CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2964 –        assertTrue(f.cancel(true));
2965 –        checkCompletedWithWrappedCancellationException(g);
2966 –    }
2967 –
2968 –    /**
2969 –     * thenAcceptAsync result completes normally after normal
2970 –     * completion of source
2971 –     */
2972 –    public void testThenAcceptAsync() {
2973 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2974 –        IncAction r = new IncAction();
2975 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2976 –        f.complete(one);
2977 –        checkCompletedNormally(g, null);
2978 –        assertEquals(r.value, (Integer) 2);
2979 –    }
2980 –
2981 –    /**
2982 –     * thenAcceptAsync result completes exceptionally after exceptional
2983 –     * completion of source
2984 –     */
2985 –    public void testThenAcceptAsync2() {
2986 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2987 –        IncAction r = new IncAction();
2988 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2989 –        f.completeExceptionally(new CFException());
2990 –        checkCompletedWithWrappedCFException(g);
2991 –    }
2992 –
2993 –    /**
2994 –     * thenAcceptAsync result completes exceptionally if action does
2995 –     */
2996 –    public void testThenAcceptAsync3() {
2997 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2998 –        FailingConsumer r = new FailingConsumer();
2999 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3000 –        f.complete(null);
3001 –        checkCompletedWithWrappedCFException(g);
3002 –    }
3003 –
3004 –    /**
3005 –     * thenAcceptAsync result completes exceptionally if source cancelled
3006 –     */
3007 –    public void testThenAcceptAsync4() {
3008 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3009 –        IncAction r = new IncAction();
3010 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3011 –        assertTrue(f.cancel(true));
3012 –        checkCompletedWithWrappedCancellationException(g);
3013 –    }
3014 –
3015 –    // async with explicit executors
3016 –
3017 –    /**
3018 –     * thenApplyAsync result completes normally after normal completion of source
3019 –     */
3020 –    public void testThenApplyAsyncE() {
3021 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3022 –        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3023 –        f.complete(one);
3024 –        checkCompletedNormally(g, two);
3025 –    }
3026 –
3027 –    /**
3028 –     * thenApplyAsync result completes exceptionally after exceptional
3029 –     * completion of source
3030 –     */
3031 –    public void testThenApplyAsync2E() {
3032 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3033 –        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3034 –        f.completeExceptionally(new CFException());
3035 –        checkCompletedWithWrappedCFException(g);
3036 –    }
3037 –
3038 –    /**
3039 –     * thenApplyAsync result completes exceptionally if action does
3040 –     */
3041 –    public void testThenApplyAsync3E() {
3042 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3043 –        FailingFunction r = new FailingFunction();
3044 –        CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3045 –        f.complete(null);
3046 –        checkCompletedWithWrappedCFException(g);
3047 –    }
3048 –
3049 –    /**
3050 –     * thenApplyAsync result completes exceptionally if source cancelled
3051 –     */
3052 –    public void testThenApplyAsync4E() {
3053 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3054 –        CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3055 –        assertTrue(f.cancel(true));
3056 –        checkCompletedWithWrappedCancellationException(g);
3057 –    }
3058 –
3059 –    /**
3060 –     * thenAcceptAsync result completes normally after normal
3061 –     * completion of source
3062 –     */
3063 –    public void testThenAcceptAsyncE() {
3064 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3065 –        IncAction r = new IncAction();
3066 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3067 –        f.complete(one);
3068 –        checkCompletedNormally(g, null);
3069 –        assertEquals(r.value, (Integer) 2);
3070 –    }
3071 –
3072 –    /**
3073 –     * thenAcceptAsync result completes exceptionally after exceptional
3074 –     * completion of source
3075 –     */
3076 –    public void testThenAcceptAsync2E() {
3077 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3078 –        IncAction r = new IncAction();
3079 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3080 –        f.completeExceptionally(new CFException());
3081 –        checkCompletedWithWrappedCFException(g);
3082 –    }
3083 –
3084 –    /**
3085 –     * thenAcceptAsync result completes exceptionally if action does
3086 –     */
3087 –    public void testThenAcceptAsync3E() {
3088 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3089 –        FailingConsumer r = new FailingConsumer();
3090 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3091 –        f.complete(null);
3092 –        checkCompletedWithWrappedCFException(g);
3093 –    }
3094 –
3095 –    /**
3096 –     * thenAcceptAsync result completes exceptionally if source cancelled
3097 –     */
3098 –    public void testThenAcceptAsync4E() {
3099 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3100 –        IncAction r = new IncAction();
3101 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3102 –        assertTrue(f.cancel(true));
3103 –        checkCompletedWithWrappedCancellationException(g);
3104 –    }
3105 –
2577      // other static methods
2578  
2579      /**
# Line 3265 | 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