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

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

Diff Legend

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