ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/CompletableFutureTest.java
(Generate patch)

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.49 by jsr166, Mon Jun 2 19:20:51 2014 UTC vs.
Revision 1.59 by jsr166, Tue Jun 3 03:54:14 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 334 | Line 334 | public class CompletableFutureTest exten
334          return (x == null) ? null : x + 1;
335      }
336  
337 <    static final Supplier<Integer> supplyOne =
338 <        () -> Integer.valueOf(1);
339 <    static final Function<Integer, Integer> inc =
340 <        (Integer x) -> Integer.valueOf(x.intValue() + 1);
341 <    static final BiFunction<Integer, Integer, Integer> subtract =
342 <        (Integer x, Integer y) -> subtract(x, y);
337 >    static final class IntegerSupplier implements Supplier<Integer> {
338 >        final ExecutionMode m;
339 >        int invocationCount = 0;
340 >        final Integer value;
341 >        IntegerSupplier(ExecutionMode m, Integer value) {
342 >            this.m = m;
343 >            this.value = value;
344 >        }
345 >        public Integer get() {
346 >            m.checkExecutionMode();
347 >            invocationCount++;
348 >            return value;
349 >        }
350 >    }
351 >        
352      static final class IncAction implements Consumer<Integer> {
353          int invocationCount = 0;
354          Integer value;
# Line 349 | Line 358 | public class CompletableFutureTest exten
358          }
359      }
360      static final class IncFunction implements Function<Integer,Integer> {
361 +        final ExecutionMode m;
362          int invocationCount = 0;
363          Integer value;
364 +        IncFunction(ExecutionMode m) { this.m = m; }
365          public Integer apply(Integer x) {
366 +            m.checkExecutionMode();
367              invocationCount++;
368              return value = inc(x);
369          }
370      }
371      static final class SubtractAction implements BiConsumer<Integer, Integer> {
372 +        final ExecutionMode m;
373          int invocationCount = 0;
374          Integer value;
375          // Check this action was invoked exactly once when result is computed.
376 +        SubtractAction(ExecutionMode m) { this.m = m; }
377          public void accept(Integer x, Integer y) {
378 +            m.checkExecutionMode();
379              invocationCount++;
380              value = subtract(x, y);
381          }
382      }
383      static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
384 +        final ExecutionMode m;
385          int invocationCount = 0;
386          Integer value;
387          // Check this action was invoked exactly once when result is computed.
388 +        SubtractFunction(ExecutionMode m) { this.m = m; }
389          public Integer apply(Integer x, Integer y) {
390 +            m.checkExecutionMode();
391              invocationCount++;
392              return value = subtract(x, y);
393          }
394      }
395      static final class Noop implements Runnable {
396 +        final ExecutionMode m;
397          int invocationCount = 0;
398 +        Noop(ExecutionMode m) { this.m = m; }
399          public void run() {
400 +            m.checkExecutionMode();
401              invocationCount++;
402          }
403      }
404  
405      static final class FailingSupplier implements Supplier<Integer> {
406 +        final ExecutionMode m;
407          int invocationCount = 0;
408 +        FailingSupplier(ExecutionMode m) { this.m = m; }
409          public Integer get() {
410 +            m.checkExecutionMode();
411              invocationCount++;
412              throw new CFException();
413          }
414      }
415      static final class FailingConsumer implements Consumer<Integer> {
416 +        final ExecutionMode m;
417          int invocationCount = 0;
418 +        FailingConsumer(ExecutionMode m) { this.m = m; }
419          public void accept(Integer x) {
420 +            m.checkExecutionMode();
421              invocationCount++;
422              throw new CFException();
423          }
424      }
425      static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
426 +        final ExecutionMode m;
427          int invocationCount = 0;
428 +        FailingBiConsumer(ExecutionMode m) { this.m = m; }
429          public void accept(Integer x, Integer y) {
430 +            m.checkExecutionMode();
431              invocationCount++;
432              throw new CFException();
433          }
434      }
435      static final class FailingFunction implements Function<Integer, Integer> {
436 +        final ExecutionMode m;
437          int invocationCount = 0;
438 +        FailingFunction(ExecutionMode m) { this.m = m; }
439          public Integer apply(Integer x) {
440 +            m.checkExecutionMode();
441              invocationCount++;
442              throw new CFException();
443          }
444      }
445      static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
446 +        final ExecutionMode m;
447          int invocationCount = 0;
448 +        FailingBiFunction(ExecutionMode m) { this.m = m; }
449          public Integer apply(Integer x, Integer y) {
450 +            m.checkExecutionMode();
451              invocationCount++;
452              throw new CFException();
453          }
454      }
455 <    static final class FailingNoop implements Runnable {
455 >    static final class FailingRunnable implements Runnable {
456 >        final ExecutionMode m;
457          int invocationCount = 0;
458 +        FailingRunnable(ExecutionMode m) { this.m = m; }
459          public void run() {
460 +            m.checkExecutionMode();
461              invocationCount++;
462              throw new CFException();
463          }
# Line 426 | Line 465 | public class CompletableFutureTest exten
465  
466      static final class CompletableFutureInc
467          implements Function<Integer, CompletableFuture<Integer>> {
468 +        final ExecutionMode m;
469          int invocationCount = 0;
470 +        CompletableFutureInc(ExecutionMode m) { this.m = m; }
471          public CompletableFuture<Integer> apply(Integer x) {
472 +            m.checkExecutionMode();
473              invocationCount++;
474              CompletableFuture<Integer> f = new CompletableFuture<>();
475              f.complete(inc(x));
# Line 437 | Line 479 | public class CompletableFutureTest exten
479  
480      static final class FailingCompletableFutureFunction
481          implements Function<Integer, CompletableFuture<Integer>> {
482 +        final ExecutionMode m;
483          int invocationCount = 0;
484 +        FailingCompletableFutureFunction(ExecutionMode m) { this.m = m; }
485          public CompletableFuture<Integer> apply(Integer x) {
486 +            m.checkExecutionMode();
487              invocationCount++;
488              throw new CFException();
489          }
# Line 446 | Line 491 | public class CompletableFutureTest exten
491  
492      // Used for explicit executor tests
493      static final class ThreadExecutor implements Executor {
494 <        AtomicInteger count = new AtomicInteger(0);
494 >        final AtomicInteger count = new AtomicInteger(0);
495 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
496 >        static boolean startedCurrentThread() {
497 >            return Thread.currentThread().getThreadGroup() == tg;
498 >        }
499  
500          public void execute(Runnable r) {
501              count.getAndIncrement();
502 <            new Thread(r).start();
502 >            new Thread(tg, r).start();
503          }
504      }
505  
# Line 463 | Line 512 | public class CompletableFutureTest exten
512              public void checkExecutionMode() {
513                  assertNull(ForkJoinTask.getPool());
514              }
515 +            public CompletableFuture<Void> runAsync(Runnable a) {
516 +                throw new UnsupportedOperationException();
517 +            }
518 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
519 +                throw new UnsupportedOperationException();
520 +            }
521              public <T> CompletableFuture<Void> thenRun
522                  (CompletableFuture<T> f, Runnable a) {
523                  return f.thenRun(a);
# Line 531 | Line 586 | public class CompletableFutureTest exten
586                  assertSame(ForkJoinPool.commonPool(),
587                             ForkJoinTask.getPool());
588              }
589 +            public CompletableFuture<Void> runAsync(Runnable a) {
590 +                return CompletableFuture.runAsync(a);
591 +            }
592 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
593 +                return CompletableFuture.supplyAsync(a);
594 +            }
595              public <T> CompletableFuture<Void> thenRun
596                  (CompletableFuture<T> f, Runnable a) {
597                  return f.thenRunAsync(a);
# Line 596 | Line 657 | public class CompletableFutureTest exten
657  
658          EXECUTOR {
659              public void checkExecutionMode() {
660 <                //TODO
660 >                assertTrue(ThreadExecutor.startedCurrentThread());
661 >            }
662 >            public CompletableFuture<Void> runAsync(Runnable a) {
663 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
664 >            }
665 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
666 >                return CompletableFuture.supplyAsync(a, new ThreadExecutor());
667              }
668              public <T> CompletableFuture<Void> thenRun
669                  (CompletableFuture<T> f, Runnable a) {
# Line 662 | Line 729 | public class CompletableFutureTest exten
729          };
730  
731          public abstract void checkExecutionMode();
732 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
733 +        public abstract <U> CompletableFuture<U> supplyAsync(Supplier<U> a);
734          public abstract <T> CompletableFuture<Void> thenRun
735              (CompletableFuture<T> f, Runnable a);
736          public abstract <T> CompletableFuture<Void> thenAccept
# Line 740 | Line 809 | public class CompletableFutureTest exten
809          if (!createIncomplete) f.completeExceptionally(ex);
810          final CompletableFuture<Integer> g = f.exceptionally
811              ((Throwable t) -> {
812 +                ExecutionMode.DEFAULT.checkExecutionMode();
813                  threadAssertSame(t, ex);
814                  a.getAndIncrement();
815                  return v1;
# Line 761 | Line 831 | public class CompletableFutureTest exten
831          if (!createIncomplete) f.completeExceptionally(ex1);
832          final CompletableFuture<Integer> g = f.exceptionally
833              ((Throwable t) -> {
834 +                ExecutionMode.DEFAULT.checkExecutionMode();
835                  threadAssertSame(t, ex1);
836                  a.getAndIncrement();
837                  throw ex2;
# Line 786 | Line 857 | public class CompletableFutureTest exten
857          final CompletableFuture<Integer> g = m.handle
858              (f,
859               (Integer x, Throwable t) -> {
860 +                m.checkExecutionMode();
861                  threadAssertSame(x, v1);
862                  threadAssertNull(t);
863                  a.getAndIncrement();
# Line 814 | Line 886 | public class CompletableFutureTest exten
886          final CompletableFuture<Integer> g = m.handle
887              (f,
888               (Integer x, Throwable t) -> {
889 +                m.checkExecutionMode();
890                  threadAssertNull(x);
891                  threadAssertSame(t, ex);
892                  a.getAndIncrement();
# Line 842 | Line 915 | public class CompletableFutureTest exten
915          final CompletableFuture<Integer> g = m.handle
916              (f,
917               (Integer x, Throwable t) -> {
918 +                m.checkExecutionMode();
919                  threadAssertNull(x);
920                  threadAssertTrue(t instanceof CancellationException);
921                  a.getAndIncrement();
# Line 869 | Line 943 | public class CompletableFutureTest exten
943          final CompletableFuture<Integer> g = m.handle
944              (f,
945               (Integer x, Throwable t) -> {
946 +                m.checkExecutionMode();
947                  threadAssertNull(x);
948                  threadAssertSame(ex1, t);
949                  a.getAndIncrement();
# Line 893 | Line 968 | public class CompletableFutureTest exten
968          final CompletableFuture<Integer> g = m.handle
969              (f,
970               (Integer x, Throwable t) -> {
971 +                m.checkExecutionMode();
972                  threadAssertSame(x, v1);
973                  threadAssertNull(t);
974                  a.getAndIncrement();
# Line 908 | Line 984 | public class CompletableFutureTest exten
984      /**
985       * runAsync completes after running Runnable
986       */
987 <    public void testRunAsync() {
988 <        Noop r = new Noop();
989 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
987 >    public void testRunAsync_normalCompletion() {
988 >        ExecutionMode[] executionModes = {
989 >            ExecutionMode.ASYNC,
990 >            ExecutionMode.EXECUTOR,
991 >        };
992 >        for (ExecutionMode m : executionModes)
993 >    {
994 >        final Noop r = new Noop(m);
995 >        final CompletableFuture<Void> f = m.runAsync(r);
996          assertNull(f.join());
915 –        assertEquals(1, r.invocationCount);
997          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());
998          assertEquals(1, r.invocationCount);
999 <        checkCompletedNormally(f, null);
929 <        assertEquals(1, exec.count.get());
930 <    }
999 >    }}
1000  
1001      /**
1002       * failing runAsync completes exceptionally after running Runnable
1003       */
1004 <    public void testRunAsync3() {
1005 <        FailingNoop r = new FailingNoop();
1006 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
1004 >    public void testRunAsync_exceptionalCompletion() {
1005 >        ExecutionMode[] executionModes = {
1006 >            ExecutionMode.ASYNC,
1007 >            ExecutionMode.EXECUTOR,
1008 >        };
1009 >        for (ExecutionMode m : executionModes)
1010 >    {
1011 >        final FailingRunnable r = new FailingRunnable(m);
1012 >        final CompletableFuture<Void> f = m.runAsync(r);
1013          checkCompletedWithWrappedCFException(f);
1014          assertEquals(1, r.invocationCount);
1015 <    }
1015 >    }}
1016  
1017      /**
1018       * supplyAsync completes with result of supplier
1019       */
1020 <    public void testSupplyAsync() {
1021 <        CompletableFuture<Integer> f;
1022 <        f = CompletableFuture.supplyAsync(supplyOne);
1023 <        assertEquals(f.join(), one);
1024 <        checkCompletedNormally(f, one);
1025 <    }
1026 <
1027 <    /**
1028 <     * supplyAsync with executor completes with result of supplier
1029 <     */
1030 <    public void testSupplyAsync2() {
1031 <        CompletableFuture<Integer> f;
1032 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
1033 <        assertEquals(f.join(), one);
959 <        checkCompletedNormally(f, one);
960 <    }
1020 >    public void testSupplyAsync_normalCompletion() {
1021 >        ExecutionMode[] executionModes = {
1022 >            ExecutionMode.ASYNC,
1023 >            ExecutionMode.EXECUTOR,
1024 >        };
1025 >        for (ExecutionMode m : executionModes)
1026 >        for (Integer v1 : new Integer[] { 1, null })
1027 >    {
1028 >        final IntegerSupplier r = new IntegerSupplier(m, v1);
1029 >        final CompletableFuture<Integer> f = m.supplyAsync(r);
1030 >        assertSame(v1, f.join());
1031 >        checkCompletedNormally(f, v1);
1032 >        assertEquals(1, r.invocationCount);
1033 >    }}
1034  
1035      /**
1036       * Failing supplyAsync completes exceptionally
1037       */
1038 <    public void testSupplyAsync3() {
1039 <        FailingSupplier r = new FailingSupplier();
1040 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1038 >    public void testSupplyAsync_exceptionalCompletion() {
1039 >        ExecutionMode[] executionModes = {
1040 >            ExecutionMode.ASYNC,
1041 >            ExecutionMode.EXECUTOR,
1042 >        };
1043 >        for (ExecutionMode m : executionModes)
1044 >    {
1045 >        FailingSupplier r = new FailingSupplier(m);
1046 >        CompletableFuture<Integer> f = m.supplyAsync(r);
1047          checkCompletedWithWrappedCFException(f);
1048          assertEquals(1, r.invocationCount);
1049 <    }
1049 >    }}
1050  
1051      // seq completion methods
1052  
# Line 980 | Line 1059 | public class CompletableFutureTest exten
1059          for (Integer v1 : new Integer[] { 1, null })
1060      {
1061          final CompletableFuture<Integer> f = new CompletableFuture<>();
1062 <        final Noop r = new Noop();
1062 >        final Noop r = new Noop(m);
1063          if (!createIncomplete) f.complete(v1);
1064          final CompletableFuture<Void> g = m.thenRun(f, r);
1065 <        if (createIncomplete) f.complete(v1);
1065 >        if (createIncomplete) {
1066 >            checkIncomplete(g);
1067 >            f.complete(v1);
1068 >        }
1069  
1070          checkCompletedNormally(g, null);
1071          checkCompletedNormally(f, v1);
# Line 1000 | Line 1082 | public class CompletableFutureTest exten
1082      {
1083          final CFException ex = new CFException();
1084          final CompletableFuture<Integer> f = new CompletableFuture<>();
1085 <        final Noop r = new Noop();
1085 >        final Noop r = new Noop(m);
1086          if (!createIncomplete) f.completeExceptionally(ex);
1087          final CompletableFuture<Void> g = m.thenRun(f, r);
1088 <        if (createIncomplete) f.completeExceptionally(ex);
1088 >        if (createIncomplete) {
1089 >            checkIncomplete(g);
1090 >            f.completeExceptionally(ex);
1091 >        }
1092  
1093          checkCompletedWithWrappedCFException(g, ex);
1094          checkCompletedWithWrappedCFException(f, ex);
# Line 1019 | Line 1104 | public class CompletableFutureTest exten
1104          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1105      {
1106          final CompletableFuture<Integer> f = new CompletableFuture<>();
1107 <        final Noop r = new Noop();
1107 >        final Noop r = new Noop(m);
1108          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1109 <        final CompletableFuture<Void> g = f.thenRun(r);
1110 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1109 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1110 >        if (createIncomplete) {
1111 >            checkIncomplete(g);
1112 >            assertTrue(f.cancel(mayInterruptIfRunning));
1113 >        }
1114  
1115          checkCompletedWithWrappedCancellationException(g);
1116          checkCancelled(f);
# Line 1038 | Line 1126 | public class CompletableFutureTest exten
1126          for (Integer v1 : new Integer[] { 1, null })
1127      {
1128          final CompletableFuture<Integer> f = new CompletableFuture<>();
1129 <        final FailingNoop r = new FailingNoop();
1129 >        final FailingRunnable r = new FailingRunnable(m);
1130          if (!createIncomplete) f.complete(v1);
1131 <        final CompletableFuture<Void> g = f.thenRun(r);
1132 <        if (createIncomplete) f.complete(v1);
1131 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1132 >        if (createIncomplete) {
1133 >            checkIncomplete(g);
1134 >            f.complete(v1);
1135 >        }
1136  
1137          checkCompletedWithWrappedCFException(g);
1138          checkCompletedNormally(f, v1);
# Line 1056 | Line 1147 | public class CompletableFutureTest exten
1147          for (Integer v1 : new Integer[] { 1, null })
1148      {
1149          final CompletableFuture<Integer> f = new CompletableFuture<>();
1150 <        final IncFunction r = new IncFunction();
1150 >        final IncFunction r = new IncFunction(m);
1151          if (!createIncomplete) f.complete(v1);
1152          final CompletableFuture<Integer> g = m.thenApply(f, r);
1153          if (createIncomplete) {
# Line 1079 | Line 1170 | public class CompletableFutureTest exten
1170      {
1171          final CFException ex = new CFException();
1172          final CompletableFuture<Integer> f = new CompletableFuture<>();
1173 <        final IncFunction r = new IncFunction();
1173 >        final IncFunction r = new IncFunction(m);
1174          if (!createIncomplete) f.completeExceptionally(ex);
1175          final CompletableFuture<Integer> g = m.thenApply(f, r);
1176 <        if (createIncomplete) f.completeExceptionally(ex);
1176 >        if (createIncomplete) {
1177 >            checkIncomplete(g);
1178 >            f.completeExceptionally(ex);
1179 >        }
1180  
1181          checkCompletedWithWrappedCFException(g, ex);
1182          checkCompletedWithWrappedCFException(f, ex);
# Line 1098 | Line 1192 | public class CompletableFutureTest exten
1192          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1193      {
1194          final CompletableFuture<Integer> f = new CompletableFuture<>();
1195 <        final IncFunction r = new IncFunction();
1195 >        final IncFunction r = new IncFunction(m);
1196          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1197 <        final CompletableFuture<Integer> g = f.thenApply(r);
1198 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1197 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1198 >        if (createIncomplete) {
1199 >            checkIncomplete(g);
1200 >            assertTrue(f.cancel(mayInterruptIfRunning));
1201 >        }
1202  
1203          checkCompletedWithWrappedCancellationException(g);
1204          checkCancelled(f);
# Line 1117 | Line 1214 | public class CompletableFutureTest exten
1214          for (Integer v1 : new Integer[] { 1, null })
1215      {
1216          final CompletableFuture<Integer> f = new CompletableFuture<>();
1217 <        final FailingFunction r = new FailingFunction();
1217 >        final FailingFunction r = new FailingFunction(m);
1218          if (!createIncomplete) f.complete(v1);
1219 <        final CompletableFuture<Integer> g = f.thenApply(r);
1220 <        if (createIncomplete) f.complete(v1);
1219 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1220 >        if (createIncomplete) {
1221 >            checkIncomplete(g);
1222 >            f.complete(v1);
1223 >        }
1224  
1225          checkCompletedWithWrappedCFException(g);
1226          checkCompletedNormally(f, v1);
# Line 1129 | Line 1229 | public class CompletableFutureTest exten
1229      /**
1230       * thenAccept result completes normally after normal completion of source
1231       */
1232 <    public void testThenAccept() {
1133 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1134 <        IncAction r = new IncAction();
1135 <        CompletableFuture<Void> g = f.thenAccept(r);
1136 <        f.complete(one);
1137 <        checkCompletedNormally(g, null);
1138 <        assertEquals(r.value, (Integer) 2);
1139 <    }
1140 <
1141 <    /**
1142 <     * thenAccept result completes exceptionally after exceptional
1143 <     * completion of source
1144 <     */
1145 <    public void testThenAccept2() {
1146 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1147 <        IncAction r = new IncAction();
1148 <        CompletableFuture<Void> g = f.thenAccept(r);
1149 <        f.completeExceptionally(new CFException());
1150 <        checkCompletedWithWrappedCFException(g);
1151 <    }
1152 <
1153 <    /**
1154 <     * thenAccept result completes exceptionally if action does
1155 <     */
1156 <    public void testThenAccept3() {
1157 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1158 <        FailingConsumer r = new FailingConsumer();
1159 <        CompletableFuture<Void> g = f.thenAccept(r);
1160 <        f.complete(one);
1161 <        checkCompletedWithWrappedCFException(g);
1162 <        assertEquals(1, r.invocationCount);
1163 <    }
1164 <
1165 <    /**
1166 <     * thenAccept result completes exceptionally if source cancelled
1167 <     */
1168 <    public void testThenAccept4() {
1169 <        CompletableFuture<Integer> f = new CompletableFuture<>();
1170 <        IncAction r = new IncAction();
1171 <        CompletableFuture<Void> g = f.thenAccept(r);
1172 <        assertTrue(f.cancel(true));
1173 <        checkCompletedWithWrappedCancellationException(g);
1174 <    }
1175 <
1176 <    /**
1177 <     * thenCombine result completes normally after normal completion
1178 <     * of sources
1179 <     */
1180 <    public void testThenCombine_normalCompletion1() {
1181 <        for (boolean createIncomplete : new boolean[] { true, false })
1182 <        for (boolean fFirst : new boolean[] { true, false })
1232 >    public void testThenAccept_normalCompletion() {
1233          for (ExecutionMode m : ExecutionMode.values())
1234 +        for (boolean createIncomplete : new boolean[] { true, false })
1235          for (Integer v1 : new Integer[] { 1, null })
1185 –        for (Integer v2 : new Integer[] { 2, null })
1236      {
1237          final CompletableFuture<Integer> f = new CompletableFuture<>();
1238 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1239 <        final SubtractFunction r = new SubtractFunction();
1240 <        CompletableFuture<Integer> h = null;
1241 <        if (createIncomplete) h = m.thenCombine(f, g, r);
1242 <
1193 <        if (fFirst)
1194 <            f.complete(v1);
1195 <        else
1196 <            g.complete(v2);
1197 <        if (createIncomplete) checkIncomplete(h);
1198 <        assertEquals(0, r.invocationCount);
1199 <        if (!fFirst)
1238 >        final IncAction r = new IncAction();
1239 >        if (!createIncomplete) f.complete(v1);
1240 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1241 >        if (createIncomplete) {
1242 >            checkIncomplete(g);
1243              f.complete(v1);
1244 <        else
1202 <            g.complete(v2);
1203 <        if (!createIncomplete) h = m.thenCombine(f, g, r);
1244 >        }
1245  
1246 <        checkCompletedNormally(h, subtract(v1, v2));
1246 >        checkCompletedNormally(g, null);
1247          checkCompletedNormally(f, v1);
1207 –        checkCompletedNormally(g, v2);
1248          assertEquals(1, r.invocationCount);
1249 +        assertEquals(inc(v1), r.value);
1250      }}
1251  
1252      /**
1253 <     * thenCombine result completes exceptionally after exceptional
1254 <     * completion of either source
1253 >     * thenAccept result completes exceptionally after exceptional
1254 >     * completion of source
1255       */
1256 <    public void testThenCombine_exceptionalCompletion1() {
1256 >    public void testThenAccept_exceptionalCompletion() {
1257          for (ExecutionMode m : ExecutionMode.values())
1258 <        for (Integer v1 : new Integer[] { 1, null })
1258 >        for (boolean createIncomplete : new boolean[] { true, false })
1259      {
1219 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1220 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1221 –        final SubtractFunction r = new SubtractFunction();
1222 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1260          final CFException ex = new CFException();
1224 –
1225 –        f.completeExceptionally(ex);
1226 –        checkIncomplete(h);
1227 –        g.complete(v1);
1228 –
1229 –        checkCompletedWithWrappedCFException(h, ex);
1230 –        checkCompletedWithWrappedCFException(f, ex);
1231 –        assertEquals(0, r.invocationCount);
1232 –        checkCompletedNormally(g, v1);
1233 –    }}
1234 –
1235 –    public void testThenCombine_exceptionalCompletion2() {
1236 –        for (ExecutionMode m : ExecutionMode.values())
1237 –        for (Integer v1 : new Integer[] { 1, null })
1238 –    {
1261          final CompletableFuture<Integer> f = new CompletableFuture<>();
1262 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1263 <        final SubtractFunction r = new SubtractFunction();
1264 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1265 <        final CFException ex = new CFException();
1266 <
1267 <        g.completeExceptionally(ex);
1268 <        checkIncomplete(h);
1247 <        f.complete(v1);
1262 >        final IncAction r = new IncAction();
1263 >        if (!createIncomplete) f.completeExceptionally(ex);
1264 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1265 >        if (createIncomplete) {
1266 >            checkIncomplete(g);
1267 >            f.completeExceptionally(ex);
1268 >        }
1269  
1249 –        checkCompletedWithWrappedCFException(h, ex);
1270          checkCompletedWithWrappedCFException(g, ex);
1271 +        checkCompletedWithWrappedCFException(f, ex);
1272          assertEquals(0, r.invocationCount);
1252 –        checkCompletedNormally(f, v1);
1273      }}
1274  
1275 <    public void testThenCombine_exceptionalCompletion3() {
1275 >    /**
1276 >     * thenAccept result completes exceptionally if action does
1277 >     */
1278 >    public void testThenAccept_actionFailed() {
1279          for (ExecutionMode m : ExecutionMode.values())
1280 +        for (boolean createIncomplete : new boolean[] { true, false })
1281          for (Integer v1 : new Integer[] { 1, null })
1282      {
1283          final CompletableFuture<Integer> f = new CompletableFuture<>();
1284 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1285 <        final SubtractFunction r = new SubtractFunction();
1286 <        final CFException ex = new CFException();
1287 <
1288 <        g.completeExceptionally(ex);
1289 <        f.complete(v1);
1290 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1284 >        final FailingConsumer r = new FailingConsumer(m);
1285 >        if (!createIncomplete) f.complete(v1);
1286 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1287 >        if (createIncomplete) {
1288 >            checkIncomplete(g);
1289 >            f.complete(v1);
1290 >        }
1291  
1292 <        checkCompletedWithWrappedCFException(h, ex);
1269 <        checkCompletedWithWrappedCFException(g, ex);
1270 <        assertEquals(0, r.invocationCount);
1292 >        checkCompletedWithWrappedCFException(g);
1293          checkCompletedNormally(f, v1);
1294      }}
1295  
1296 <    public void testThenCombine_exceptionalCompletion4() {
1296 >    /**
1297 >     * thenAccept result completes exceptionally if source cancelled
1298 >     */
1299 >    public void testThenAccept_sourceCancelled() {
1300          for (ExecutionMode m : ExecutionMode.values())
1301 <        for (Integer v1 : new Integer[] { 1, null })
1301 >        for (boolean createIncomplete : new boolean[] { true, false })
1302 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1303      {
1304          final CompletableFuture<Integer> f = new CompletableFuture<>();
1305 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1306 <        final SubtractFunction r = new SubtractFunction();
1307 <        final CFException ex = new CFException();
1308 <
1309 <        f.completeExceptionally(ex);
1310 <        g.complete(v1);
1311 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1305 >        final IncAction r = new IncAction();
1306 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1307 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1308 >        if (createIncomplete) {
1309 >            checkIncomplete(g);
1310 >            assertTrue(f.cancel(mayInterruptIfRunning));
1311 >        }
1312  
1313 <        checkCompletedWithWrappedCFException(h, ex);
1314 <        checkCompletedWithWrappedCFException(f, ex);
1313 >        checkCompletedWithWrappedCancellationException(g);
1314 >        checkCancelled(f);
1315          assertEquals(0, r.invocationCount);
1290 –        checkCompletedNormally(g, v1);
1316      }}
1317  
1318      /**
1319 <     * thenCombine result completes exceptionally if action does
1319 >     * thenCombine result completes normally after normal completion
1320 >     * of sources
1321       */
1322 <    public void testThenCombine_actionFailed1() {
1322 >    public void testThenCombine_normalCompletion() {
1323          for (ExecutionMode m : ExecutionMode.values())
1324 +        for (boolean createIncomplete : new boolean[] { true, false })
1325 +        for (boolean fFirst : new boolean[] { true, false })
1326          for (Integer v1 : new Integer[] { 1, null })
1327          for (Integer v2 : new Integer[] { 2, null })
1328      {
1329          final CompletableFuture<Integer> f = new CompletableFuture<>();
1330          final CompletableFuture<Integer> g = new CompletableFuture<>();
1331 <        final FailingBiFunction r = new FailingBiFunction();
1304 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1305 <
1306 <        f.complete(v1);
1307 <        checkIncomplete(h);
1308 <        g.complete(v2);
1309 <
1310 <        checkCompletedWithWrappedCFException(h);
1311 <        checkCompletedNormally(f, v1);
1312 <        checkCompletedNormally(g, v2);
1313 <    }}
1331 >        final SubtractFunction r = new SubtractFunction(m);
1332  
1333 <    public void testThenCombine_actionFailed2() {
1334 <        for (ExecutionMode m : ExecutionMode.values())
1335 <        for (Integer v1 : new Integer[] { 1, null })
1318 <        for (Integer v2 : new Integer[] { 2, null })
1319 <    {
1320 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1321 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1322 <        final FailingBiFunction r = new FailingBiFunction();
1333 >        if (fFirst) f.complete(v1); else g.complete(v2);
1334 >        if (!createIncomplete)
1335 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1336          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1337 +        if (createIncomplete) {
1338 +            checkIncomplete(h);
1339 +            assertEquals(0, r.invocationCount);
1340 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1341 +        }
1342  
1343 <        g.complete(v2);
1326 <        checkIncomplete(h);
1327 <        f.complete(v1);
1328 <
1329 <        checkCompletedWithWrappedCFException(h);
1343 >        checkCompletedNormally(h, subtract(v1, v2));
1344          checkCompletedNormally(f, v1);
1345          checkCompletedNormally(g, v2);
1346 +        assertEquals(1, r.invocationCount);
1347      }}
1348  
1349      /**
1350 <     * thenCombine result completes exceptionally if either source cancelled
1350 >     * thenCombine result completes exceptionally after exceptional
1351 >     * completion of either source
1352       */
1353 <    public void testThenCombine_sourceCancelled1() {
1353 >    public void testThenCombine_exceptionalCompletion() {
1354          for (ExecutionMode m : ExecutionMode.values())
1355 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1355 >        for (boolean createIncomplete : new boolean[] { true, false })
1356 >        for (boolean fFirst : new boolean[] { true, false })
1357          for (Integer v1 : new Integer[] { 1, null })
1358      {
1359          final CompletableFuture<Integer> f = new CompletableFuture<>();
1360          final CompletableFuture<Integer> g = new CompletableFuture<>();
1361 <        final SubtractFunction r = new SubtractFunction();
1362 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1361 >        final CFException ex = new CFException();
1362 >        final SubtractFunction r = new SubtractFunction(m);
1363  
1364 <        assertTrue(f.cancel(mayInterruptIfRunning));
1365 <        checkIncomplete(h);
1366 <        g.complete(v1);
1364 >        (fFirst ? f : g).complete(v1);
1365 >        if (!createIncomplete)
1366 >            (!fFirst ? f : g).completeExceptionally(ex);
1367 >        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1368 >        if (createIncomplete) {
1369 >            checkIncomplete(h);
1370 >            (!fFirst ? f : g).completeExceptionally(ex);
1371 >        }
1372  
1373 <        checkCompletedWithWrappedCancellationException(h);
1352 <        checkCancelled(f);
1373 >        checkCompletedWithWrappedCFException(h, ex);
1374          assertEquals(0, r.invocationCount);
1375 <        checkCompletedNormally(g, v1);
1375 >        checkCompletedNormally(fFirst ? f : g, v1);
1376 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1377      }}
1378  
1379 <    public void testThenCombine_sourceCancelled2() {
1379 >    /**
1380 >     * thenCombine result completes exceptionally if action does
1381 >     */
1382 >    public void testThenCombine_actionFailed() {
1383          for (ExecutionMode m : ExecutionMode.values())
1384 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1384 >        for (boolean fFirst : new boolean[] { true, false })
1385          for (Integer v1 : new Integer[] { 1, null })
1386 +        for (Integer v2 : new Integer[] { 2, null })
1387      {
1388          final CompletableFuture<Integer> f = new CompletableFuture<>();
1389          final CompletableFuture<Integer> g = new CompletableFuture<>();
1390 <        final SubtractFunction r = new SubtractFunction();
1390 >        final FailingBiFunction r = new FailingBiFunction(m);
1391          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1392  
1393 <        assertTrue(g.cancel(mayInterruptIfRunning));
1394 <        checkIncomplete(h);
1395 <        f.complete(v1);
1393 >        if (fFirst) {
1394 >            f.complete(v1);
1395 >            g.complete(v2);
1396 >        } else {
1397 >            g.complete(v2);
1398 >            f.complete(v1);
1399 >        }
1400  
1401 <        checkCompletedWithWrappedCancellationException(h);
1372 <        checkCancelled(g);
1373 <        assertEquals(0, r.invocationCount);
1401 >        checkCompletedWithWrappedCFException(h);
1402          checkCompletedNormally(f, v1);
1403 +        checkCompletedNormally(g, v2);
1404      }}
1405  
1406 <    public void testThenCombine_sourceCancelled3() {
1406 >    /**
1407 >     * thenCombine result completes exceptionally if either source cancelled
1408 >     */
1409 >    public void testThenCombine_sourceCancelled() {
1410          for (ExecutionMode m : ExecutionMode.values())
1411          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1412 +        for (boolean createIncomplete : new boolean[] { true, false })
1413 +        for (boolean fFirst : new boolean[] { true, false })
1414          for (Integer v1 : new Integer[] { 1, null })
1415      {
1416          final CompletableFuture<Integer> f = new CompletableFuture<>();
1417          final CompletableFuture<Integer> g = new CompletableFuture<>();
1418 <        final SubtractFunction r = new SubtractFunction();
1418 >        final SubtractFunction r = new SubtractFunction(m);
1419  
1420 <        assertTrue(g.cancel(mayInterruptIfRunning));
1421 <        f.complete(v1);
1422 <        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1389 <
1390 <        checkCompletedWithWrappedCancellationException(h);
1391 <        checkCancelled(g);
1392 <        assertEquals(0, r.invocationCount);
1393 <        checkCompletedNormally(f, v1);
1394 <    }}
1395 <
1396 <    public void testThenCombine_sourceCancelled4() {
1397 <        for (ExecutionMode m : ExecutionMode.values())
1398 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1399 <        for (Integer v1 : new Integer[] { 1, null })
1400 <    {
1401 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1402 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1403 <        final SubtractFunction r = new SubtractFunction();
1404 <
1405 <        assertTrue(f.cancel(mayInterruptIfRunning));
1406 <        g.complete(v1);
1420 >        (fFirst ? f : g).complete(v1);
1421 >        if (!createIncomplete)
1422 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1423          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1424 +        if (createIncomplete) {
1425 +            checkIncomplete(h);
1426 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1427 +        }
1428  
1429          checkCompletedWithWrappedCancellationException(h);
1430 <        checkCancelled(f);
1430 >        checkCancelled(!fFirst ? f : g);
1431          assertEquals(0, r.invocationCount);
1432 <        checkCompletedNormally(g, v1);
1432 >        checkCompletedNormally(fFirst ? f : g, v1);
1433      }}
1434  
1435      /**
1436       * thenAcceptBoth result completes normally after normal
1437       * completion of sources
1438       */
1439 <    public void testThenAcceptBoth_normalCompletion1() {
1420 <        for (ExecutionMode m : ExecutionMode.values())
1421 <        for (Integer v1 : new Integer[] { 1, null })
1422 <        for (Integer v2 : new Integer[] { 2, null })
1423 <    {
1424 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1425 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1426 <        final SubtractAction r = new SubtractAction();
1427 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1428 <
1429 <        f.complete(v1);
1430 <        checkIncomplete(h);
1431 <        assertEquals(0, r.invocationCount);
1432 <        g.complete(v2);
1433 <
1434 <        checkCompletedNormally(h, null);
1435 <        assertEquals(subtract(v1, v2), r.value);
1436 <        checkCompletedNormally(f, v1);
1437 <        checkCompletedNormally(g, v2);
1438 <    }}
1439 <
1440 <    public void testThenAcceptBoth_normalCompletion2() {
1441 <        for (ExecutionMode m : ExecutionMode.values())
1442 <        for (Integer v1 : new Integer[] { 1, null })
1443 <        for (Integer v2 : new Integer[] { 2, null })
1444 <    {
1445 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1446 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1447 <        final SubtractAction r = new SubtractAction();
1448 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1449 <
1450 <        g.complete(v2);
1451 <        checkIncomplete(h);
1452 <        assertEquals(0, r.invocationCount);
1453 <        f.complete(v1);
1454 <
1455 <        checkCompletedNormally(h, null);
1456 <        assertEquals(subtract(v1, v2), r.value);
1457 <        checkCompletedNormally(f, v1);
1458 <        checkCompletedNormally(g, v2);
1459 <    }}
1460 <
1461 <    public void testThenAcceptBoth_normalCompletion3() {
1462 <        for (ExecutionMode m : ExecutionMode.values())
1463 <        for (Integer v1 : new Integer[] { 1, null })
1464 <        for (Integer v2 : new Integer[] { 2, null })
1465 <    {
1466 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1467 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1468 <        final SubtractAction r = new SubtractAction();
1469 <
1470 <        g.complete(v2);
1471 <        f.complete(v1);
1472 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1473 <
1474 <        checkCompletedNormally(h, null);
1475 <        assertEquals(subtract(v1, v2), r.value);
1476 <        checkCompletedNormally(f, v1);
1477 <        checkCompletedNormally(g, v2);
1478 <    }}
1479 <
1480 <    public void testThenAcceptBoth_normalCompletion4() {
1439 >    public void testThenAcceptBoth_normalCompletion() {
1440          for (ExecutionMode m : ExecutionMode.values())
1441 +        for (boolean createIncomplete : new boolean[] { true, false })
1442 +        for (boolean fFirst : new boolean[] { true, false })
1443          for (Integer v1 : new Integer[] { 1, null })
1444          for (Integer v2 : new Integer[] { 2, null })
1445      {
1446          final CompletableFuture<Integer> f = new CompletableFuture<>();
1447          final CompletableFuture<Integer> g = new CompletableFuture<>();
1448 <        final SubtractAction r = new SubtractAction();
1448 >        final SubtractAction r = new SubtractAction(m);
1449  
1450 <        f.complete(v1);
1451 <        g.complete(v2);
1450 >        if (fFirst) f.complete(v1); else g.complete(v2);
1451 >        if (!createIncomplete)
1452 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1453          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1454 +        if (createIncomplete) {
1455 +            checkIncomplete(h);
1456 +            assertEquals(0, r.invocationCount);
1457 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1458 +        }
1459  
1460          checkCompletedNormally(h, null);
1461          assertEquals(subtract(v1, v2), r.value);
# Line 1500 | Line 1467 | public class CompletableFutureTest exten
1467       * thenAcceptBoth result completes exceptionally after exceptional
1468       * completion of either source
1469       */
1470 <    public void testThenAcceptBoth_exceptionalCompletion1() {
1504 <        for (ExecutionMode m : ExecutionMode.values())
1505 <        for (Integer v1 : new Integer[] { 1, null })
1506 <    {
1507 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1508 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1509 <        final SubtractAction r = new SubtractAction();
1510 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1511 <        final CFException ex = new CFException();
1512 <
1513 <        f.completeExceptionally(ex);
1514 <        checkIncomplete(h);
1515 <        g.complete(v1);
1516 <
1517 <        checkCompletedWithWrappedCFException(h, ex);
1518 <        checkCompletedWithWrappedCFException(f, ex);
1519 <        assertEquals(0, r.invocationCount);
1520 <        checkCompletedNormally(g, v1);
1521 <    }}
1522 <
1523 <    public void testThenAcceptBoth_exceptionalCompletion2() {
1524 <        for (ExecutionMode m : ExecutionMode.values())
1525 <        for (Integer v1 : new Integer[] { 1, null })
1526 <    {
1527 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1528 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1529 <        final SubtractAction r = new SubtractAction();
1530 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1531 <        final CFException ex = new CFException();
1532 <
1533 <        g.completeExceptionally(ex);
1534 <        checkIncomplete(h);
1535 <        f.complete(v1);
1536 <
1537 <        checkCompletedWithWrappedCFException(h, ex);
1538 <        checkCompletedWithWrappedCFException(g, ex);
1539 <        assertEquals(0, r.invocationCount);
1540 <        checkCompletedNormally(f, v1);
1541 <    }}
1542 <
1543 <    public void testThenAcceptBoth_exceptionalCompletion3() {
1544 <        for (ExecutionMode m : ExecutionMode.values())
1545 <        for (Integer v1 : new Integer[] { 1, null })
1546 <    {
1547 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1548 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1549 <        final SubtractAction r = new SubtractAction();
1550 <        final CFException ex = new CFException();
1551 <
1552 <        g.completeExceptionally(ex);
1553 <        f.complete(v1);
1554 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1555 <
1556 <        checkCompletedWithWrappedCFException(h, ex);
1557 <        checkCompletedWithWrappedCFException(g, ex);
1558 <        assertEquals(0, r.invocationCount);
1559 <        checkCompletedNormally(f, v1);
1560 <    }}
1561 <
1562 <    public void testThenAcceptBoth_exceptionalCompletion4() {
1470 >    public void testThenAcceptBoth_exceptionalCompletion() {
1471          for (ExecutionMode m : ExecutionMode.values())
1472 +        for (boolean createIncomplete : new boolean[] { true, false })
1473 +        for (boolean fFirst : new boolean[] { true, false })
1474          for (Integer v1 : new Integer[] { 1, null })
1475      {
1476          final CompletableFuture<Integer> f = new CompletableFuture<>();
1477          final CompletableFuture<Integer> g = new CompletableFuture<>();
1568 –        final SubtractAction r = new SubtractAction();
1478          final CFException ex = new CFException();
1479 +        final SubtractAction r = new SubtractAction(m);
1480  
1481 <        f.completeExceptionally(ex);
1482 <        g.complete(v1);
1481 >        (fFirst ? f : g).complete(v1);
1482 >        if (!createIncomplete)
1483 >            (!fFirst ? f : g).completeExceptionally(ex);
1484          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1485 +        if (createIncomplete) {
1486 +            checkIncomplete(h);
1487 +            (!fFirst ? f : g).completeExceptionally(ex);
1488 +        }
1489  
1490          checkCompletedWithWrappedCFException(h, ex);
1576 –        checkCompletedWithWrappedCFException(f, ex);
1491          assertEquals(0, r.invocationCount);
1492 <        checkCompletedNormally(g, v1);
1492 >        checkCompletedNormally(fFirst ? f : g, v1);
1493 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1494      }}
1495  
1496      /**
1497       * thenAcceptBoth result completes exceptionally if action does
1498       */
1499 <    public void testThenAcceptBoth_actionFailed1() {
1585 <        for (ExecutionMode m : ExecutionMode.values())
1586 <        for (Integer v1 : new Integer[] { 1, null })
1587 <        for (Integer v2 : new Integer[] { 2, null })
1588 <    {
1589 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1590 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1591 <        final FailingBiConsumer r = new FailingBiConsumer();
1592 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1593 <
1594 <        f.complete(v1);
1595 <        checkIncomplete(h);
1596 <        g.complete(v2);
1597 <
1598 <        checkCompletedWithWrappedCFException(h);
1599 <        checkCompletedNormally(f, v1);
1600 <        checkCompletedNormally(g, v2);
1601 <    }}
1602 <
1603 <    public void testThenAcceptBoth_actionFailed2() {
1499 >    public void testThenAcceptBoth_actionFailed() {
1500          for (ExecutionMode m : ExecutionMode.values())
1501 +        for (boolean fFirst : new boolean[] { true, false })
1502          for (Integer v1 : new Integer[] { 1, null })
1503          for (Integer v2 : new Integer[] { 2, null })
1504      {
1505          final CompletableFuture<Integer> f = new CompletableFuture<>();
1506          final CompletableFuture<Integer> g = new CompletableFuture<>();
1507 <        final FailingBiConsumer r = new FailingBiConsumer();
1507 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1508          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1509  
1510 <        g.complete(v2);
1511 <        checkIncomplete(h);
1512 <        f.complete(v1);
1510 >        if (fFirst) {
1511 >            f.complete(v1);
1512 >            g.complete(v2);
1513 >        } else {
1514 >            g.complete(v2);
1515 >            f.complete(v1);
1516 >        }
1517  
1518          checkCompletedWithWrappedCFException(h);
1519          checkCompletedNormally(f, v1);
# Line 1622 | Line 1523 | public class CompletableFutureTest exten
1523      /**
1524       * thenAcceptBoth result completes exceptionally if either source cancelled
1525       */
1526 <    public void testThenAcceptBoth_sourceCancelled1() {
1626 <        for (ExecutionMode m : ExecutionMode.values())
1627 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1628 <        for (Integer v1 : new Integer[] { 1, null })
1629 <    {
1630 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1631 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1632 <        final SubtractAction r = new SubtractAction();
1633 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1634 <
1635 <        assertTrue(f.cancel(mayInterruptIfRunning));
1636 <        checkIncomplete(h);
1637 <        g.complete(v1);
1638 <
1639 <        checkCompletedWithWrappedCancellationException(h);
1640 <        checkCancelled(f);
1641 <        assertEquals(0, r.invocationCount);
1642 <        checkCompletedNormally(g, v1);
1643 <    }}
1644 <
1645 <    public void testThenAcceptBoth_sourceCancelled2() {
1646 <        for (ExecutionMode m : ExecutionMode.values())
1647 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1648 <        for (Integer v1 : new Integer[] { 1, null })
1649 <    {
1650 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1651 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1652 <        final SubtractAction r = new SubtractAction();
1653 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1654 <
1655 <        assertTrue(g.cancel(mayInterruptIfRunning));
1656 <        checkIncomplete(h);
1657 <        f.complete(v1);
1658 <
1659 <        checkCompletedWithWrappedCancellationException(h);
1660 <        checkCancelled(g);
1661 <        assertEquals(0, r.invocationCount);
1662 <        checkCompletedNormally(f, v1);
1663 <    }}
1664 <
1665 <    public void testThenAcceptBoth_sourceCancelled3() {
1666 <        for (ExecutionMode m : ExecutionMode.values())
1667 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1668 <        for (Integer v1 : new Integer[] { 1, null })
1669 <    {
1670 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1671 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1672 <        final SubtractAction r = new SubtractAction();
1673 <
1674 <        assertTrue(g.cancel(mayInterruptIfRunning));
1675 <        f.complete(v1);
1676 <        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1677 <
1678 <        checkCompletedWithWrappedCancellationException(h);
1679 <        checkCancelled(g);
1680 <        assertEquals(0, r.invocationCount);
1681 <        checkCompletedNormally(f, v1);
1682 <    }}
1683 <
1684 <    public void testThenAcceptBoth_sourceCancelled4() {
1526 >    public void testThenAcceptBoth_sourceCancelled() {
1527          for (ExecutionMode m : ExecutionMode.values())
1528          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1529 +        for (boolean createIncomplete : new boolean[] { true, false })
1530 +        for (boolean fFirst : new boolean[] { true, false })
1531          for (Integer v1 : new Integer[] { 1, null })
1532      {
1533          final CompletableFuture<Integer> f = new CompletableFuture<>();
1534          final CompletableFuture<Integer> g = new CompletableFuture<>();
1535 <        final SubtractAction r = new SubtractAction();
1535 >        final SubtractAction r = new SubtractAction(m);
1536  
1537 <        assertTrue(f.cancel(mayInterruptIfRunning));
1538 <        g.complete(v1);
1537 >        (fFirst ? f : g).complete(v1);
1538 >        if (!createIncomplete)
1539 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1540          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1541 +        if (createIncomplete) {
1542 +            checkIncomplete(h);
1543 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1544 +        }
1545  
1546          checkCompletedWithWrappedCancellationException(h);
1547 <        checkCancelled(f);
1547 >        checkCancelled(!fFirst ? f : g);
1548          assertEquals(0, r.invocationCount);
1549 <        checkCompletedNormally(g, v1);
1549 >        checkCompletedNormally(fFirst ? f : g, v1);
1550      }}
1551  
1552      /**
1553       * runAfterBoth result completes normally after normal
1554       * completion of sources
1555       */
1556 <    public void testRunAfterBoth_normalCompletion1() {
1708 <        for (ExecutionMode m : ExecutionMode.values())
1709 <        for (Integer v1 : new Integer[] { 1, null })
1710 <        for (Integer v2 : new Integer[] { 2, null })
1711 <    {
1712 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1713 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1714 <        final Noop r = new Noop();
1715 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1716 <
1717 <        f.complete(v1);
1718 <        checkIncomplete(h);
1719 <        assertEquals(0, r.invocationCount);
1720 <        g.complete(v2);
1721 <
1722 <        checkCompletedNormally(h, null);
1723 <        assertEquals(1, r.invocationCount);
1724 <        checkCompletedNormally(f, v1);
1725 <        checkCompletedNormally(g, v2);
1726 <    }}
1727 <
1728 <    public void testRunAfterBoth_normalCompletion2() {
1729 <        for (ExecutionMode m : ExecutionMode.values())
1730 <        for (Integer v1 : new Integer[] { 1, null })
1731 <        for (Integer v2 : new Integer[] { 2, null })
1732 <    {
1733 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1734 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1735 <        final Noop r = new Noop();
1736 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1737 <
1738 <        g.complete(v2);
1739 <        checkIncomplete(h);
1740 <        assertEquals(0, r.invocationCount);
1741 <        f.complete(v1);
1742 <
1743 <        checkCompletedNormally(h, null);
1744 <        assertEquals(1, r.invocationCount);
1745 <        checkCompletedNormally(f, v1);
1746 <        checkCompletedNormally(g, v2);
1747 <    }}
1748 <
1749 <    public void testRunAfterBoth_normalCompletion3() {
1750 <        for (ExecutionMode m : ExecutionMode.values())
1751 <        for (Integer v1 : new Integer[] { 1, null })
1752 <        for (Integer v2 : new Integer[] { 2, null })
1753 <    {
1754 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1755 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1756 <        final Noop r = new Noop();
1757 <
1758 <        g.complete(v2);
1759 <        f.complete(v1);
1760 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1761 <
1762 <        checkCompletedNormally(h, null);
1763 <        assertEquals(1, r.invocationCount);
1764 <        checkCompletedNormally(f, v1);
1765 <        checkCompletedNormally(g, v2);
1766 <    }}
1767 <
1768 <    public void testRunAfterBoth_normalCompletion4() {
1556 >    public void testRunAfterBoth_normalCompletion() {
1557          for (ExecutionMode m : ExecutionMode.values())
1558 +        for (boolean createIncomplete : new boolean[] { true, false })
1559 +        for (boolean fFirst : new boolean[] { true, false })
1560          for (Integer v1 : new Integer[] { 1, null })
1561          for (Integer v2 : new Integer[] { 2, null })
1562      {
1563          final CompletableFuture<Integer> f = new CompletableFuture<>();
1564          final CompletableFuture<Integer> g = new CompletableFuture<>();
1565 <        final Noop r = new Noop();
1565 >        final Noop r = new Noop(m);
1566  
1567 <        f.complete(v1);
1568 <        g.complete(v2);
1567 >        if (fFirst) f.complete(v1); else g.complete(v2);
1568 >        if (!createIncomplete)
1569 >            if (!fFirst) f.complete(v1); else g.complete(v2);
1570          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1571 +        if (createIncomplete) {
1572 +            checkIncomplete(h);
1573 +            assertEquals(0, r.invocationCount);
1574 +            if (!fFirst) f.complete(v1); else g.complete(v2);
1575 +        }
1576  
1577          checkCompletedNormally(h, null);
1578          assertEquals(1, r.invocationCount);
# Line 1788 | Line 1584 | public class CompletableFutureTest exten
1584       * runAfterBoth result completes exceptionally after exceptional
1585       * completion of either source
1586       */
1587 <    public void testRunAfterBoth_exceptionalCompletion1() {
1792 <        for (ExecutionMode m : ExecutionMode.values())
1793 <        for (Integer v1 : new Integer[] { 1, null })
1794 <    {
1795 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1796 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1797 <        final Noop r = new Noop();
1798 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1799 <        final CFException ex = new CFException();
1800 <
1801 <        f.completeExceptionally(ex);
1802 <        checkIncomplete(h);
1803 <        g.complete(v1);
1804 <
1805 <        checkCompletedWithWrappedCFException(h, ex);
1806 <        checkCompletedWithWrappedCFException(f, ex);
1807 <        assertEquals(0, r.invocationCount);
1808 <        checkCompletedNormally(g, v1);
1809 <    }}
1810 <
1811 <    public void testRunAfterBoth_exceptionalCompletion2() {
1812 <        for (ExecutionMode m : ExecutionMode.values())
1813 <        for (Integer v1 : new Integer[] { 1, null })
1814 <    {
1815 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1816 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1817 <        final Noop r = new Noop();
1818 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1819 <        final CFException ex = new CFException();
1820 <
1821 <        g.completeExceptionally(ex);
1822 <        checkIncomplete(h);
1823 <        f.complete(v1);
1824 <
1825 <        checkCompletedWithWrappedCFException(h, ex);
1826 <        checkCompletedWithWrappedCFException(g, ex);
1827 <        assertEquals(0, r.invocationCount);
1828 <        checkCompletedNormally(f, v1);
1829 <    }}
1830 <
1831 <    public void testRunAfterBoth_exceptionalCompletion3() {
1832 <        for (ExecutionMode m : ExecutionMode.values())
1833 <        for (Integer v1 : new Integer[] { 1, null })
1834 <    {
1835 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1836 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1837 <        final Noop r = new Noop();
1838 <        final CFException ex = new CFException();
1839 <
1840 <        g.completeExceptionally(ex);
1841 <        f.complete(v1);
1842 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1843 <
1844 <        checkCompletedWithWrappedCFException(h, ex);
1845 <        checkCompletedWithWrappedCFException(g, ex);
1846 <        assertEquals(0, r.invocationCount);
1847 <        checkCompletedNormally(f, v1);
1848 <    }}
1849 <
1850 <    public void testRunAfterBoth_exceptionalCompletion4() {
1587 >    public void testRunAfterBoth_exceptionalCompletion() {
1588          for (ExecutionMode m : ExecutionMode.values())
1589 +        for (boolean createIncomplete : new boolean[] { true, false })
1590 +        for (boolean fFirst : new boolean[] { true, false })
1591          for (Integer v1 : new Integer[] { 1, null })
1592      {
1593          final CompletableFuture<Integer> f = new CompletableFuture<>();
1594          final CompletableFuture<Integer> g = new CompletableFuture<>();
1856 –        final Noop r = new Noop();
1595          final CFException ex = new CFException();
1596 +        final Noop r = new Noop(m);
1597  
1598 <        f.completeExceptionally(ex);
1599 <        g.complete(v1);
1598 >        (fFirst ? f : g).complete(v1);
1599 >        if (!createIncomplete)
1600 >            (!fFirst ? f : g).completeExceptionally(ex);
1601          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1602 +        if (createIncomplete) {
1603 +            checkIncomplete(h);
1604 +            (!fFirst ? f : g).completeExceptionally(ex);
1605 +        }
1606  
1607          checkCompletedWithWrappedCFException(h, ex);
1864 –        checkCompletedWithWrappedCFException(f, ex);
1608          assertEquals(0, r.invocationCount);
1609 <        checkCompletedNormally(g, v1);
1609 >        checkCompletedNormally(fFirst ? f : g, v1);
1610 >        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1611      }}
1612  
1613      /**
1614       * runAfterBoth result completes exceptionally if action does
1615       */
1616 <    public void testRunAfterBoth_actionFailed1() {
1873 <        for (ExecutionMode m : ExecutionMode.values())
1874 <        for (Integer v1 : new Integer[] { 1, null })
1875 <        for (Integer v2 : new Integer[] { 2, null })
1876 <    {
1877 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1878 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1879 <        final FailingNoop r = new FailingNoop();
1880 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1881 <
1882 <        f.complete(v1);
1883 <        checkIncomplete(h);
1884 <        g.complete(v2);
1885 <
1886 <        checkCompletedWithWrappedCFException(h);
1887 <        checkCompletedNormally(f, v1);
1888 <        checkCompletedNormally(g, v2);
1889 <    }}
1890 <
1891 <    public void testRunAfterBoth_actionFailed2() {
1616 >    public void testRunAfterBoth_actionFailed() {
1617          for (ExecutionMode m : ExecutionMode.values())
1618 +        for (boolean fFirst : new boolean[] { true, false })
1619          for (Integer v1 : new Integer[] { 1, null })
1620          for (Integer v2 : new Integer[] { 2, null })
1621      {
1622          final CompletableFuture<Integer> f = new CompletableFuture<>();
1623          final CompletableFuture<Integer> g = new CompletableFuture<>();
1624 <        final FailingNoop r = new FailingNoop();
1899 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1624 >        final FailingRunnable r = new FailingRunnable(m);
1625  
1626 <        g.complete(v2);
1627 <        checkIncomplete(h);
1628 <        f.complete(v1);
1626 >        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1627 >        if (fFirst) {
1628 >            f.complete(v1);
1629 >            g.complete(v2);
1630 >        } else {
1631 >            g.complete(v2);
1632 >            f.complete(v1);
1633 >        }
1634 >        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1635  
1636 <        checkCompletedWithWrappedCFException(h);
1636 >        checkCompletedWithWrappedCFException(h1);
1637 >        checkCompletedWithWrappedCFException(h2);
1638          checkCompletedNormally(f, v1);
1639          checkCompletedNormally(g, v2);
1640      }}
# Line 1910 | Line 1642 | public class CompletableFutureTest exten
1642      /**
1643       * runAfterBoth result completes exceptionally if either source cancelled
1644       */
1645 <    public void testRunAfterBoth_sourceCancelled1() {
1914 <        for (ExecutionMode m : ExecutionMode.values())
1915 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1916 <        for (Integer v1 : new Integer[] { 1, null })
1917 <    {
1918 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1919 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1920 <        final Noop r = new Noop();
1921 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1922 <
1923 <        assertTrue(f.cancel(mayInterruptIfRunning));
1924 <        checkIncomplete(h);
1925 <        g.complete(v1);
1926 <
1927 <        checkCompletedWithWrappedCancellationException(h);
1928 <        checkCancelled(f);
1929 <        assertEquals(0, r.invocationCount);
1930 <        checkCompletedNormally(g, v1);
1931 <    }}
1932 <
1933 <    public void testRunAfterBoth_sourceCancelled2() {
1934 <        for (ExecutionMode m : ExecutionMode.values())
1935 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1936 <        for (Integer v1 : new Integer[] { 1, null })
1937 <    {
1938 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1939 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1940 <        final Noop r = new Noop();
1941 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1942 <
1943 <        assertTrue(g.cancel(mayInterruptIfRunning));
1944 <        checkIncomplete(h);
1945 <        f.complete(v1);
1946 <
1947 <        checkCompletedWithWrappedCancellationException(h);
1948 <        checkCancelled(g);
1949 <        assertEquals(0, r.invocationCount);
1950 <        checkCompletedNormally(f, v1);
1951 <    }}
1952 <
1953 <    public void testRunAfterBoth_sourceCancelled3() {
1645 >    public void testRunAfterBoth_sourceCancelled() {
1646          for (ExecutionMode m : ExecutionMode.values())
1647          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1648 +        for (boolean createIncomplete : new boolean[] { true, false })
1649 +        for (boolean fFirst : new boolean[] { true, false })
1650          for (Integer v1 : new Integer[] { 1, null })
1651      {
1652          final CompletableFuture<Integer> f = new CompletableFuture<>();
1653          final CompletableFuture<Integer> g = new CompletableFuture<>();
1654 <        final Noop r = new Noop();
1654 >        final Noop r = new Noop(m);
1655  
1962 –        assertTrue(g.cancel(mayInterruptIfRunning));
1963 –        f.complete(v1);
1964 –        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1656  
1657 <        checkCompletedWithWrappedCancellationException(h);
1658 <        checkCancelled(g);
1659 <        assertEquals(0, r.invocationCount);
1969 <        checkCompletedNormally(f, v1);
1970 <    }}
1971 <
1972 <    public void testRunAfterBoth_sourceCancelled4() {
1973 <        for (ExecutionMode m : ExecutionMode.values())
1974 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1975 <        for (Integer v1 : new Integer[] { 1, null })
1976 <    {
1977 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1978 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1979 <        final Noop r = new Noop();
1980 <
1981 <        assertTrue(f.cancel(mayInterruptIfRunning));
1982 <        g.complete(v1);
1657 >        (fFirst ? f : g).complete(v1);
1658 >        if (!createIncomplete)
1659 >            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1660          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1661 +        if (createIncomplete) {
1662 +            checkIncomplete(h);
1663 +            assertTrue((!fFirst ? f : g).cancel(mayInterruptIfRunning));
1664 +        }
1665  
1666          checkCompletedWithWrappedCancellationException(h);
1667 <        checkCancelled(f);
1667 >        checkCancelled(!fFirst ? f : g);
1668          assertEquals(0, r.invocationCount);
1669 <        checkCompletedNormally(g, v1);
1669 >        checkCompletedNormally(fFirst ? f : g, v1);
1670      }}
1671  
1672      /**
1673       * applyToEither result completes normally after normal completion
1674       * of either source
1675       */
1676 <    public void testApplyToEither_normalCompletion1() {
1676 >    public void testApplyToEither_normalCompletion() {
1677          for (ExecutionMode m : ExecutionMode.values())
1678 +        for (boolean createIncomplete : new boolean[] { true, false })
1679 +        for (boolean fFirst : new boolean[] { true, false })
1680          for (Integer v1 : new Integer[] { 1, null })
1681          for (Integer v2 : new Integer[] { 2, null })
1682      {
1683          final CompletableFuture<Integer> f = new CompletableFuture<>();
1684          final CompletableFuture<Integer> g = new CompletableFuture<>();
1685 <        final IncFunction r = new IncFunction();
2003 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1685 >        final IncFunction r = new IncFunction(m);
1686  
1687 <        f.complete(v1);
1688 <        checkCompletedNormally(h, inc(v1));
1689 <        g.complete(v2);
1687 >        if (!createIncomplete)
1688 >            if (fFirst) f.complete(v1); else g.complete(v2);
1689 >        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1690 >        if (createIncomplete) {
1691 >            checkIncomplete(h);
1692 >            assertEquals(0, r.invocationCount);
1693 >            if (fFirst) f.complete(v1); else g.complete(v2);
1694 >        }
1695 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1696 >        if (!fFirst) f.complete(v1); else g.complete(v2);
1697  
1698          checkCompletedNormally(f, v1);
1699          checkCompletedNormally(g, v2);
1700 <        checkCompletedNormally(h, inc(v1));
1700 >        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1701      }}
1702  
1703 <    public void testApplyToEither_normalCompletion2() {
1703 >    public void testApplyToEither_normalCompletionBothAvailable() {
1704          for (ExecutionMode m : ExecutionMode.values())
1705 +        for (boolean fFirst : new boolean[] { true, false })
1706          for (Integer v1 : new Integer[] { 1, null })
1707          for (Integer v2 : new Integer[] { 2, null })
1708      {
1709          final CompletableFuture<Integer> f = new CompletableFuture<>();
1710          final CompletableFuture<Integer> g = new CompletableFuture<>();
1711 <        final IncFunction r = new IncFunction();
2022 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2023 <
2024 <        g.complete(v2);
2025 <        checkCompletedNormally(h, inc(v2));
2026 <        f.complete(v1);
2027 <
2028 <        checkCompletedNormally(f, v1);
2029 <        checkCompletedNormally(g, v2);
2030 <        checkCompletedNormally(h, inc(v2));
2031 <        }}
1711 >        final IncFunction r = new IncFunction(m);
1712  
1713 <    public void testApplyToEither_normalCompletion3() {
1714 <        for (ExecutionMode m : ExecutionMode.values())
1715 <        for (Integer v1 : new Integer[] { 1, null })
1716 <        for (Integer v2 : new Integer[] { 2, null })
1717 <    {
1718 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1719 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2040 <        final IncFunction r = new IncFunction();
1713 >        if (fFirst) {
1714 >            f.complete(v1);
1715 >            g.complete(v2);
1716 >        } else {
1717 >            g.complete(v2);
1718 >            f.complete(v1);
1719 >        }
1720  
2042 –        f.complete(v1);
2043 –        g.complete(v2);
1721          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1722  
1723          checkCompletedNormally(f, v1);
# Line 2058 | Line 1735 | public class CompletableFutureTest exten
1735       */
1736      public void testApplyToEither_exceptionalCompletion1() {
1737          for (ExecutionMode m : ExecutionMode.values())
1738 +        for (boolean createIncomplete : new boolean[] { true, false })
1739 +        for (boolean fFirst : new boolean[] { true, false })
1740          for (Integer v1 : new Integer[] { 1, null })
1741      {
1742          final CompletableFuture<Integer> f = new CompletableFuture<>();
1743          final CompletableFuture<Integer> g = new CompletableFuture<>();
2065 –        final IncFunction r = new IncFunction();
2066 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1744          final CFException ex = new CFException();
1745 +        final IncFunction r = new IncFunction(m);
1746  
1747 <        f.completeExceptionally(ex);
2070 <        checkCompletedWithWrappedCFException(h, ex);
2071 <        g.complete(v1);
2072 <
2073 <        assertEquals(0, r.invocationCount);
2074 <        checkCompletedNormally(g, v1);
2075 <        checkCompletedWithWrappedCFException(f, ex);
2076 <        checkCompletedWithWrappedCFException(h, ex);
2077 <    }}
2078 <
2079 <    public void testApplyToEither_exceptionalCompletion2() {
2080 <        for (ExecutionMode m : ExecutionMode.values())
2081 <        for (Integer v1 : new Integer[] { 1, null })
2082 <    {
2083 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2084 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2085 <        final IncFunction r = new IncFunction();
1747 >        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1748          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1749 <        final CFException ex = new CFException();
1749 >        if (createIncomplete) {
1750 >            checkIncomplete(h);
1751 >            assertEquals(0, r.invocationCount);
1752 >            (fFirst ? f : g).completeExceptionally(ex);
1753 >        }
1754  
2089 –        g.completeExceptionally(ex);
1755          checkCompletedWithWrappedCFException(h, ex);
1756 <        f.complete(v1);
1756 >        (!fFirst ? f : g).complete(v1);
1757  
1758          assertEquals(0, r.invocationCount);
1759 <        checkCompletedNormally(f, v1);
1760 <        checkCompletedWithWrappedCFException(g, ex);
1759 >        checkCompletedNormally(!fFirst ? f : g, v1);
1760 >        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1761          checkCompletedWithWrappedCFException(h, ex);
1762      }}
1763  
1764 <    public void testApplyToEither_exceptionalCompletion3() {
1764 >    public void testApplyToEither_exceptionalCompletion2() {
1765          for (ExecutionMode m : ExecutionMode.values())
1766 +        for (boolean reverseArgs : new boolean[] { true, false })
1767 +        for (boolean fFirst : new boolean[] { true, false })
1768          for (Integer v1 : new Integer[] { 1, null })
1769      {
1770          final CompletableFuture<Integer> f = new CompletableFuture<>();
1771          final CompletableFuture<Integer> g = new CompletableFuture<>();
1772 <        final IncFunction r = new IncFunction();
1772 >        final IncFunction r1 = new IncFunction(m);
1773 >        final IncFunction r2 = new IncFunction(m);
1774          final CFException ex = new CFException();
1775 <
1776 <        g.completeExceptionally(ex);
1777 <        f.complete(v1);
1778 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1775 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1776 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1777 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1778 >        if (fFirst) {
1779 >            f.complete(v1);
1780 >            g.completeExceptionally(ex);
1781 >        } else {
1782 >            g.completeExceptionally(ex);
1783 >            f.complete(v1);
1784 >        }
1785 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1786  
1787          // unspecified behavior
2113 –        Integer v;
1788          try {
1789 <            assertEquals(inc(v1), h.join());
1790 <            assertEquals(1, r.invocationCount);
1789 >            assertEquals(inc(v1), h1.join());
1790 >            assertEquals(1, r1.invocationCount);
1791          } catch (CompletionException ok) {
1792 <            checkCompletedWithWrappedCFException(h, ex);
1793 <            assertEquals(0, r.invocationCount);
1792 >            checkCompletedWithWrappedCFException(h1, ex);
1793 >            assertEquals(0, r1.invocationCount);
1794          }
1795  
2122 –        checkCompletedWithWrappedCFException(g, ex);
2123 –        checkCompletedNormally(f, v1);
2124 –    }}
2125 –
2126 –    public void testApplyToEither_exceptionalCompletion4() {
2127 –        for (ExecutionMode m : ExecutionMode.values())
2128 –        for (Integer v1 : new Integer[] { 1, null })
2129 –    {
2130 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2131 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2132 –        final IncFunction r = new IncFunction();
2133 –        final CFException ex = new CFException();
2134 –
2135 –        f.completeExceptionally(ex);
2136 –        g.complete(v1);
2137 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2138 –
2139 –        // unspecified behavior
2140 –        Integer v;
1796          try {
1797 <            assertEquals(inc(v1), h.join());
1798 <            assertEquals(1, r.invocationCount);
1797 >            assertEquals(inc(v1), h2.join());
1798 >            assertEquals(1, r2.invocationCount);
1799          } catch (CompletionException ok) {
1800 <            checkCompletedWithWrappedCFException(h, ex);
1801 <            assertEquals(0, r.invocationCount);
1800 >            checkCompletedWithWrappedCFException(h2, ex);
1801 >            assertEquals(0, r2.invocationCount);
1802          }
1803  
1804 <        checkCompletedWithWrappedCFException(f, ex);
1805 <        checkCompletedNormally(g, v1);
1804 >        checkCompletedWithWrappedCFException(g, ex);
1805 >        checkCompletedNormally(f, v1);
1806      }}
1807  
1808      /**
# Line 2160 | Line 1815 | public class CompletableFutureTest exten
1815      {
1816          final CompletableFuture<Integer> f = new CompletableFuture<>();
1817          final CompletableFuture<Integer> g = new CompletableFuture<>();
1818 <        final FailingFunction r = new FailingFunction();
1818 >        final FailingFunction r = new FailingFunction(m);
1819          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1820  
1821          f.complete(v1);
# Line 2177 | Line 1832 | public class CompletableFutureTest exten
1832      {
1833          final CompletableFuture<Integer> f = new CompletableFuture<>();
1834          final CompletableFuture<Integer> g = new CompletableFuture<>();
1835 <        final FailingFunction r = new FailingFunction();
1835 >        final FailingFunction r = new FailingFunction(m);
1836          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1837  
1838          g.complete(v2);
# Line 2193 | Line 1848 | public class CompletableFutureTest exten
1848      public void testApplyToEither_sourceCancelled1() {
1849          for (ExecutionMode m : ExecutionMode.values())
1850          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1851 +        for (boolean createIncomplete : new boolean[] { true, false })
1852 +        for (boolean fFirst : new boolean[] { true, false })
1853          for (Integer v1 : new Integer[] { 1, null })
1854      {
1855          final CompletableFuture<Integer> f = new CompletableFuture<>();
1856          final CompletableFuture<Integer> g = new CompletableFuture<>();
1857 <        final IncFunction r = new IncFunction();
2201 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1857 >        final IncFunction r = new IncFunction(m);
1858  
1859 <        assertTrue(f.cancel(mayInterruptIfRunning));
2204 <        checkCompletedWithWrappedCancellationException(h);
2205 <        g.complete(v1);
2206 <
2207 <        checkCancelled(f);
2208 <        assertEquals(0, r.invocationCount);
2209 <        checkCompletedNormally(g, v1);
2210 <        checkCompletedWithWrappedCancellationException(h);
2211 <    }}
2212 <
2213 <    public void testApplyToEither_sourceCancelled2() {
2214 <        for (ExecutionMode m : ExecutionMode.values())
2215 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2216 <        for (Integer v1 : new Integer[] { 1, null })
2217 <    {
2218 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2219 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2220 <        final IncFunction r = new IncFunction();
1859 >        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1860          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1861 +        if (createIncomplete) {
1862 +            checkIncomplete(h);
1863 +            assertEquals(0, r.invocationCount);
1864 +            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1865 +        }
1866  
2223 –        assertTrue(g.cancel(mayInterruptIfRunning));
1867          checkCompletedWithWrappedCancellationException(h);
1868 <        f.complete(v1);
1868 >        (!fFirst ? f : g).complete(v1);
1869  
2227 –        checkCancelled(g);
1870          assertEquals(0, r.invocationCount);
1871 <        checkCompletedNormally(f, v1);
1871 >        checkCompletedNormally(!fFirst ? f : g, v1);
1872 >        checkCancelled(fFirst ? f : g);
1873          checkCompletedWithWrappedCancellationException(h);
1874      }}
1875  
1876 <    public void testApplyToEither_sourceCancelled3() {
1876 >    public void testApplyToEither_sourceCancelled2() {
1877          for (ExecutionMode m : ExecutionMode.values())
1878          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1879 +        for (boolean reverseArgs : new boolean[] { true, false })
1880 +        for (boolean fFirst : new boolean[] { true, false })
1881          for (Integer v1 : new Integer[] { 1, null })
1882      {
1883          final CompletableFuture<Integer> f = new CompletableFuture<>();
1884          final CompletableFuture<Integer> g = new CompletableFuture<>();
1885 <        final IncFunction r = new IncFunction();
1885 >        final IncFunction r1 = new IncFunction(m);
1886 >        final IncFunction r2 = new IncFunction(m);
1887 >        final CFException ex = new CFException();
1888 >        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1889 >        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1890  
1891 <        assertTrue(g.cancel(mayInterruptIfRunning));
1892 <        f.complete(v1);
1893 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1891 >        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1892 >        if (fFirst) {
1893 >            f.complete(v1);
1894 >            assertTrue(g.cancel(mayInterruptIfRunning));
1895 >        } else {
1896 >            assertTrue(g.cancel(mayInterruptIfRunning));
1897 >            f.complete(v1);
1898 >        }
1899 >        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1900  
1901          // unspecified behavior
2247 –        Integer v;
1902          try {
1903 <            assertEquals(inc(v1), h.join());
1904 <            assertEquals(1, r.invocationCount);
1903 >            assertEquals(inc(v1), h1.join());
1904 >            assertEquals(1, r1.invocationCount);
1905          } catch (CompletionException ok) {
1906 <            checkCompletedWithWrappedCancellationException(h);
1907 <            assertEquals(0, r.invocationCount);
1906 >            checkCompletedWithWrappedCancellationException(h1);
1907 >            assertEquals(0, r1.invocationCount);
1908          }
1909  
2256 –        checkCancelled(g);
2257 –        checkCompletedNormally(f, v1);
2258 –    }}
2259 –
2260 –    public void testApplyToEither_sourceCancelled4() {
2261 –        for (ExecutionMode m : ExecutionMode.values())
2262 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2263 –        for (Integer v1 : new Integer[] { 1, null })
2264 –    {
2265 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2266 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2267 –        final IncFunction r = new IncFunction();
2268 –
2269 –        assertTrue(f.cancel(mayInterruptIfRunning));
2270 –        g.complete(v1);
2271 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2272 –
2273 –        // unspecified behavior
2274 –        Integer v;
1910          try {
1911 <            assertEquals(inc(v1), h.join());
1912 <            assertEquals(1, r.invocationCount);
1911 >            assertEquals(inc(v1), h2.join());
1912 >            assertEquals(1, r2.invocationCount);
1913          } catch (CompletionException ok) {
1914 <            checkCompletedWithWrappedCancellationException(h);
1915 <            assertEquals(0, r.invocationCount);
1914 >            checkCompletedWithWrappedCancellationException(h2);
1915 >            assertEquals(0, r2.invocationCount);
1916          }
1917  
1918 <        checkCancelled(f);
1919 <        checkCompletedNormally(g, v1);
1918 >        checkCancelled(g);
1919 >        checkCompletedNormally(f, v1);
1920      }}
1921  
1922      /**
# Line 2460 | Line 2095 | public class CompletableFutureTest exten
2095      {
2096          final CompletableFuture<Integer> f = new CompletableFuture<>();
2097          final CompletableFuture<Integer> g = new CompletableFuture<>();
2098 <        final FailingConsumer r = new FailingConsumer();
2098 >        final FailingConsumer r = new FailingConsumer(m);
2099          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2100  
2101          f.complete(v1);
# Line 2477 | Line 2112 | public class CompletableFutureTest exten
2112      {
2113          final CompletableFuture<Integer> f = new CompletableFuture<>();
2114          final CompletableFuture<Integer> g = new CompletableFuture<>();
2115 <        final FailingConsumer r = new FailingConsumer();
2115 >        final FailingConsumer r = new FailingConsumer(m);
2116          final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2117  
2118          g.complete(v2);
# Line 2597 | Line 2232 | public class CompletableFutureTest exten
2232      {
2233          final CompletableFuture<Integer> f = new CompletableFuture<>();
2234          final CompletableFuture<Integer> g = new CompletableFuture<>();
2235 <        final Noop r = new Noop();
2235 >        final Noop r = new Noop(m);
2236          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2237  
2238          f.complete(v1);
# Line 2618 | Line 2253 | public class CompletableFutureTest exten
2253      {
2254          final CompletableFuture<Integer> f = new CompletableFuture<>();
2255          final CompletableFuture<Integer> g = new CompletableFuture<>();
2256 <        final Noop r = new Noop();
2256 >        final Noop r = new Noop(m);
2257          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2258  
2259          g.complete(v2);
# Line 2639 | Line 2274 | public class CompletableFutureTest exten
2274      {
2275          final CompletableFuture<Integer> f = new CompletableFuture<>();
2276          final CompletableFuture<Integer> g = new CompletableFuture<>();
2277 <        final Noop r = new Noop();
2277 >        final Noop r = new Noop(m);
2278  
2279          f.complete(v1);
2280          g.complete(v2);
# Line 2661 | Line 2296 | public class CompletableFutureTest exten
2296      {
2297          final CompletableFuture<Integer> f = new CompletableFuture<>();
2298          final CompletableFuture<Integer> g = new CompletableFuture<>();
2299 <        final Noop r = new Noop();
2299 >        final Noop r = new Noop(m);
2300          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2301          final CFException ex = new CFException();
2302  
# Line 2681 | Line 2316 | public class CompletableFutureTest exten
2316      {
2317          final CompletableFuture<Integer> f = new CompletableFuture<>();
2318          final CompletableFuture<Integer> g = new CompletableFuture<>();
2319 <        final Noop r = new Noop();
2319 >        final Noop r = new Noop(m);
2320          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2321          final CFException ex = new CFException();
2322  
# Line 2701 | Line 2336 | public class CompletableFutureTest exten
2336      {
2337          final CompletableFuture<Integer> f = new CompletableFuture<>();
2338          final CompletableFuture<Integer> g = new CompletableFuture<>();
2339 <        final Noop r = new Noop();
2339 >        final Noop r = new Noop(m);
2340          final CFException ex = new CFException();
2341  
2342          g.completeExceptionally(ex);
# Line 2728 | Line 2363 | public class CompletableFutureTest exten
2363      {
2364          final CompletableFuture<Integer> f = new CompletableFuture<>();
2365          final CompletableFuture<Integer> g = new CompletableFuture<>();
2366 <        final Noop r = new Noop();
2366 >        final Noop r = new Noop(m);
2367          final CFException ex = new CFException();
2368  
2369          f.completeExceptionally(ex);
# Line 2759 | Line 2394 | public class CompletableFutureTest exten
2394      {
2395          final CompletableFuture<Integer> f = new CompletableFuture<>();
2396          final CompletableFuture<Integer> g = new CompletableFuture<>();
2397 <        final FailingNoop r = new FailingNoop();
2397 >        final FailingRunnable r = new FailingRunnable(m);
2398          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2399  
2400          f.complete(v1);
# Line 2776 | Line 2411 | public class CompletableFutureTest exten
2411      {
2412          final CompletableFuture<Integer> f = new CompletableFuture<>();
2413          final CompletableFuture<Integer> g = new CompletableFuture<>();
2414 <        final FailingNoop r = new FailingNoop();
2414 >        final FailingRunnable r = new FailingRunnable(m);
2415          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2416  
2417          g.complete(v2);
# Line 2796 | Line 2431 | public class CompletableFutureTest exten
2431      {
2432          final CompletableFuture<Integer> f = new CompletableFuture<>();
2433          final CompletableFuture<Integer> g = new CompletableFuture<>();
2434 <        final Noop r = new Noop();
2434 >        final Noop r = new Noop(m);
2435          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2436  
2437          assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2816 | Line 2451 | public class CompletableFutureTest exten
2451      {
2452          final CompletableFuture<Integer> f = new CompletableFuture<>();
2453          final CompletableFuture<Integer> g = new CompletableFuture<>();
2454 <        final Noop r = new Noop();
2454 >        final Noop r = new Noop(m);
2455          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2456  
2457          assertTrue(g.cancel(mayInterruptIfRunning));
# Line 2836 | Line 2471 | public class CompletableFutureTest exten
2471      {
2472          final CompletableFuture<Integer> f = new CompletableFuture<>();
2473          final CompletableFuture<Integer> g = new CompletableFuture<>();
2474 <        final Noop r = new Noop();
2474 >        final Noop r = new Noop(m);
2475  
2476          assertTrue(g.cancel(mayInterruptIfRunning));
2477          f.complete(v1);
# Line 2863 | Line 2498 | public class CompletableFutureTest exten
2498      {
2499          final CompletableFuture<Integer> f = new CompletableFuture<>();
2500          final CompletableFuture<Integer> g = new CompletableFuture<>();
2501 <        final Noop r = new Noop();
2501 >        final Noop r = new Noop(m);
2502  
2503          assertTrue(f.cancel(mayInterruptIfRunning));
2504          g.complete(v1);
# Line 2892 | Line 2527 | public class CompletableFutureTest exten
2527          for (Integer v1 : new Integer[] { 1, null })
2528      {
2529          final CompletableFuture<Integer> f = new CompletableFuture<>();
2530 <        final CompletableFutureInc r = new CompletableFutureInc();
2530 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2531          if (!createIncomplete) f.complete(v1);
2532 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2532 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2533          if (createIncomplete) f.complete(v1);
2534  
2535          checkCompletedNormally(g, inc(v1));
# Line 2911 | Line 2546 | public class CompletableFutureTest exten
2546          for (boolean createIncomplete : new boolean[] { true, false })
2547      {
2548          final CFException ex = new CFException();
2549 <        final CompletableFutureInc r = new CompletableFutureInc();
2549 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2550          final CompletableFuture<Integer> f = new CompletableFuture<>();
2551          if (!createIncomplete) f.completeExceptionally(ex);
2552 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2552 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2553          if (createIncomplete) f.completeExceptionally(ex);
2554  
2555          checkCompletedWithWrappedCFException(g, ex);
# Line 2932 | Line 2567 | public class CompletableFutureTest exten
2567      {
2568          final CompletableFuture<Integer> f = new CompletableFuture<>();
2569          final FailingCompletableFutureFunction r
2570 <            = new FailingCompletableFutureFunction();
2570 >            = new FailingCompletableFutureFunction(m);
2571          if (!createIncomplete) f.complete(v1);
2572 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2572 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2573          if (createIncomplete) f.complete(v1);
2574  
2575          checkCompletedWithWrappedCFException(g);
# Line 2950 | Line 2585 | public class CompletableFutureTest exten
2585          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2586      {
2587          final CompletableFuture<Integer> f = new CompletableFuture<>();
2588 <        final CompletableFutureInc r = new CompletableFutureInc();
2588 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2589          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2590 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2591 <        if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2590 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2591 >        if (createIncomplete) {
2592 >            checkIncomplete(g);
2593 >            assertTrue(f.cancel(mayInterruptIfRunning));
2594 >        }
2595  
2596          checkCompletedWithWrappedCancellationException(g);
2597          checkCancelled(f);
2598      }}
2599  
2962 –    // asyncs
2963 –
2964 –    /**
2965 –     * thenAcceptAsync result completes normally after normal
2966 –     * completion of source
2967 –     */
2968 –    public void testThenAcceptAsync() {
2969 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2970 –        IncAction r = new IncAction();
2971 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2972 –        f.complete(one);
2973 –        checkCompletedNormally(g, null);
2974 –        assertEquals(r.value, (Integer) 2);
2975 –    }
2976 –
2977 –    /**
2978 –     * thenAcceptAsync result completes exceptionally after exceptional
2979 –     * completion of source
2980 –     */
2981 –    public void testThenAcceptAsync2() {
2982 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2983 –        IncAction r = new IncAction();
2984 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2985 –        f.completeExceptionally(new CFException());
2986 –        checkCompletedWithWrappedCFException(g);
2987 –    }
2988 –
2989 –    /**
2990 –     * thenAcceptAsync result completes exceptionally if action does
2991 –     */
2992 –    public void testThenAcceptAsync3() {
2993 –        CompletableFuture<Integer> f = new CompletableFuture<>();
2994 –        FailingConsumer r = new FailingConsumer();
2995 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
2996 –        f.complete(null);
2997 –        checkCompletedWithWrappedCFException(g);
2998 –    }
2999 –
3000 –    /**
3001 –     * thenAcceptAsync result completes exceptionally if source cancelled
3002 –     */
3003 –    public void testThenAcceptAsync4() {
3004 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3005 –        IncAction r = new IncAction();
3006 –        CompletableFuture<Void> g = f.thenAcceptAsync(r);
3007 –        assertTrue(f.cancel(true));
3008 –        checkCompletedWithWrappedCancellationException(g);
3009 –    }
3010 –
3011 –    // async with explicit executors
3012 –
3013 –    /**
3014 –     * thenAcceptAsync result completes normally after normal
3015 –     * completion of source
3016 –     */
3017 –    public void testThenAcceptAsyncE() {
3018 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3019 –        IncAction r = new IncAction();
3020 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3021 –        f.complete(one);
3022 –        checkCompletedNormally(g, null);
3023 –        assertEquals(r.value, (Integer) 2);
3024 –    }
3025 –
3026 –    /**
3027 –     * thenAcceptAsync result completes exceptionally after exceptional
3028 –     * completion of source
3029 –     */
3030 –    public void testThenAcceptAsync2E() {
3031 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3032 –        IncAction r = new IncAction();
3033 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3034 –        f.completeExceptionally(new CFException());
3035 –        checkCompletedWithWrappedCFException(g);
3036 –    }
3037 –
3038 –    /**
3039 –     * thenAcceptAsync result completes exceptionally if action does
3040 –     */
3041 –    public void testThenAcceptAsync3E() {
3042 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3043 –        FailingConsumer r = new FailingConsumer();
3044 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3045 –        f.complete(null);
3046 –        checkCompletedWithWrappedCFException(g);
3047 –    }
3048 –
3049 –    /**
3050 –     * thenAcceptAsync result completes exceptionally if source cancelled
3051 –     */
3052 –    public void testThenAcceptAsync4E() {
3053 –        CompletableFuture<Integer> f = new CompletableFuture<>();
3054 –        IncAction r = new IncAction();
3055 –        CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3056 –        assertTrue(f.cancel(true));
3057 –        checkCompletedWithWrappedCancellationException(g);
3058 –    }
3059 –
2600      // other static methods
2601  
2602      /**
# Line 3074 | Line 2614 | public class CompletableFutureTest exten
2614       */
2615      public void testAllOf_normal() throws Exception {
2616          for (int k = 1; k < 20; ++k) {
2617 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2617 >            CompletableFuture<Integer>[] fs
2618 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2619              for (int i = 0; i < k; ++i)
2620                  fs[i] = new CompletableFuture<>();
2621              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
# Line 3088 | Line 2629 | public class CompletableFutureTest exten
2629          }
2630      }
2631  
2632 +    public void testAllOf_backwards() throws Exception {
2633 +        for (int k = 1; k < 20; ++k) {
2634 +            CompletableFuture<Integer>[] fs
2635 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2636 +            for (int i = 0; i < k; ++i)
2637 +                fs[i] = new CompletableFuture<>();
2638 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2639 +            for (int i = k - 1; i >= 0; i--) {
2640 +                checkIncomplete(f);
2641 +                checkIncomplete(CompletableFuture.allOf(fs));
2642 +                fs[i].complete(one);
2643 +            }
2644 +            checkCompletedNormally(f, null);
2645 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
2646 +        }
2647 +    }
2648 +
2649      /**
2650       * anyOf(no component futures) returns an incomplete future
2651       */
# Line 3146 | Line 2704 | public class CompletableFutureTest exten
2704          Runnable[] throwingActions = {
2705              () -> CompletableFuture.supplyAsync(null),
2706              () -> CompletableFuture.supplyAsync(null, exec),
2707 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
2707 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
2708  
2709              () -> CompletableFuture.runAsync(null),
2710              () -> CompletableFuture.runAsync(null, exec),
# Line 3219 | Line 2777 | public class CompletableFutureTest exten
2777  
2778              () -> f.thenCompose(null),
2779              () -> f.thenComposeAsync(null),
2780 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2780 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2781              () -> f.thenComposeAsync(null, exec),
2782  
2783              () -> f.exceptionally(null),

Diff Legend

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