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

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

Diff Legend

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