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.53 by jsr166, Mon Jun 2 20:20:47 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 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 <        FailingRunnable r = new FailingRunnable();
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) {
# Line 1003 | 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) {
# Line 1025 | 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);
1111 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1112          if (createIncomplete) {
1113              checkIncomplete(g);
1114              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1047 | Line 1128 | public class CompletableFutureTest exten
1128          for (Integer v1 : new Integer[] { 1, null })
1129      {
1130          final CompletableFuture<Integer> f = new CompletableFuture<>();
1131 <        final FailingRunnable r = new FailingRunnable();
1131 >        final FailingRunnable r = new FailingRunnable(m);
1132          if (!createIncomplete) f.complete(v1);
1133 <        final CompletableFuture<Void> g = f.thenRun(r);
1133 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1134          if (createIncomplete) {
1135              checkIncomplete(g);
1136              f.complete(v1);
# Line 1068 | 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 1091 | 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) {
# Line 1113 | 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);
1199 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1200          if (createIncomplete) {
1201              checkIncomplete(g);
1202              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1135 | 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);
1221 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1222          if (createIncomplete) {
1223              checkIncomplete(g);
1224              f.complete(v1);
# Line 1194 | Line 1275 | public class CompletableFutureTest exten
1275      }}
1276  
1277      /**
1278 <     * thenAccept result completes exceptionally if action does
1278 >     * thenAccept result completes exceptionally if source cancelled
1279       */
1280 <    public void testThenAccept_actionFailed() {
1280 >    public void testThenAccept_sourceCancelled() {
1281          for (ExecutionMode m : ExecutionMode.values())
1282          for (boolean createIncomplete : new boolean[] { true, false })
1283 <        for (Integer v1 : new Integer[] { 1, null })
1283 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1284      {
1285          final CompletableFuture<Integer> f = new CompletableFuture<>();
1286 <        final FailingConsumer r = new FailingConsumer();
1287 <        if (!createIncomplete) f.complete(v1);
1288 <        final CompletableFuture<Void> g = f.thenAccept(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 <            f.complete(v1);
1291 >            assertTrue(f.cancel(mayInterruptIfRunning));
1292          }
1293  
1294 <        checkCompletedWithWrappedCFException(g);
1295 <        checkCompletedNormally(f, v1);
1294 >        checkCompletedWithWrappedCancellationException(g);
1295 >        checkCancelled(f);
1296 >        assertEquals(0, r.invocationCount);
1297      }}
1298  
1299      /**
1300 <     * thenAccept result completes exceptionally if source cancelled
1300 >     * thenAccept result completes exceptionally if action does
1301       */
1302 <    public void testThenAccept_sourceCancelled() {
1302 >    public void testThenAccept_actionFailed() {
1303          for (ExecutionMode m : ExecutionMode.values())
1304          for (boolean createIncomplete : new boolean[] { true, false })
1305 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1305 >        for (Integer v1 : new Integer[] { 1, null })
1306      {
1307          final CompletableFuture<Integer> f = new CompletableFuture<>();
1308 <        final IncAction r = new IncAction();
1309 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1310 <        final CompletableFuture<Void> g = f.thenAccept(r);
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 <            assertTrue(f.cancel(mayInterruptIfRunning));
1313 >            f.complete(v1);
1314          }
1315  
1316 <        checkCompletedWithWrappedCancellationException(g);
1317 <        checkCancelled(f);
1236 <        assertEquals(0, r.invocationCount);
1316 >        checkCompletedWithWrappedCFException(g);
1317 >        checkCompletedNormally(f, v1);
1318      }}
1319  
1320      /**
# Line 1249 | Line 1330 | public class CompletableFutureTest exten
1330      {
1331          final CompletableFuture<Integer> f = new CompletableFuture<>();
1332          final CompletableFuture<Integer> g = new CompletableFuture<>();
1333 <        final SubtractFunction r = new SubtractFunction();
1333 >        final SubtractFunction r = new SubtractFunction(m);
1334  
1335          if (fFirst) f.complete(v1); else g.complete(v2);
1336          if (!createIncomplete)
# Line 1280 | Line 1361 | public class CompletableFutureTest exten
1361          final CompletableFuture<Integer> f = new CompletableFuture<>();
1362          final CompletableFuture<Integer> g = new CompletableFuture<>();
1363          final CFException ex = new CFException();
1364 <        final SubtractFunction r = new SubtractFunction();
1364 >        final SubtractFunction r = new SubtractFunction(m);
1365  
1366          (fFirst ? f : g).complete(v1);
1367          if (!createIncomplete)
# Line 1298 | Line 1379 | public class CompletableFutureTest exten
1379      }}
1380  
1381      /**
1301 –     * thenCombine result completes exceptionally if action does
1302 –     */
1303 –    public void testThenCombine_actionFailed() {
1304 –        for (ExecutionMode m : ExecutionMode.values())
1305 –        for (boolean fFirst : new boolean[] { true, false })
1306 –        for (Integer v1 : new Integer[] { 1, null })
1307 –        for (Integer v2 : new Integer[] { 2, null })
1308 –    {
1309 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1310 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1311 –        final FailingBiFunction r = new FailingBiFunction();
1312 –        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1313 –
1314 –        if (fFirst) {
1315 –            f.complete(v1);
1316 –            g.complete(v2);
1317 –        } else {
1318 –            g.complete(v2);
1319 –            f.complete(v1);
1320 –        }
1321 –
1322 –        checkCompletedWithWrappedCFException(h);
1323 –        checkCompletedNormally(f, v1);
1324 –        checkCompletedNormally(g, v2);
1325 –    }}
1326 –
1327 –    /**
1382       * thenCombine result completes exceptionally if either source cancelled
1383       */
1384      public void testThenCombine_sourceCancelled() {
# Line 1336 | Line 1390 | public class CompletableFutureTest exten
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          (fFirst ? f : g).complete(v1);
1396          if (!createIncomplete)
# Line 1354 | Line 1408 | public class CompletableFutureTest exten
1408      }}
1409  
1410      /**
1411 +     * thenCombine result completes exceptionally if action does
1412 +     */
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 FailingBiFunction r = new FailingBiFunction(m);
1422 +        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1423 +
1424 +        if (fFirst) {
1425 +            f.complete(v1);
1426 +            g.complete(v2);
1427 +        } else {
1428 +            g.complete(v2);
1429 +            f.complete(v1);
1430 +        }
1431 +
1432 +        checkCompletedWithWrappedCFException(h);
1433 +        checkCompletedNormally(f, v1);
1434 +        checkCompletedNormally(g, v2);
1435 +    }}
1436 +
1437 +    /**
1438       * thenAcceptBoth result completes normally after normal
1439       * completion of sources
1440       */
# Line 1366 | Line 1447 | public class CompletableFutureTest exten
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          if (fFirst) f.complete(v1); else g.complete(v2);
1453          if (!createIncomplete)
# Line 1397 | Line 1478 | public class CompletableFutureTest exten
1478          final CompletableFuture<Integer> f = new CompletableFuture<>();
1479          final CompletableFuture<Integer> g = new CompletableFuture<>();
1480          final CFException ex = new CFException();
1481 <        final SubtractAction r = new SubtractAction();
1481 >        final SubtractAction r = new SubtractAction(m);
1482  
1483          (fFirst ? f : g).complete(v1);
1484          if (!createIncomplete)
# Line 1415 | Line 1496 | public class CompletableFutureTest exten
1496      }}
1497  
1498      /**
1418 –     * thenAcceptBoth result completes exceptionally if action does
1419 –     */
1420 –    public void testThenAcceptBoth_actionFailed() {
1421 –        for (ExecutionMode m : ExecutionMode.values())
1422 –        for (boolean fFirst : new boolean[] { true, false })
1423 –        for (Integer v1 : new Integer[] { 1, null })
1424 –        for (Integer v2 : new Integer[] { 2, null })
1425 –    {
1426 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1427 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1428 –        final FailingBiConsumer r = new FailingBiConsumer();
1429 –        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1430 –
1431 –        if (fFirst) {
1432 –            f.complete(v1);
1433 –            g.complete(v2);
1434 –        } else {
1435 –            g.complete(v2);
1436 –            f.complete(v1);
1437 –        }
1438 –
1439 –        checkCompletedWithWrappedCFException(h);
1440 –        checkCompletedNormally(f, v1);
1441 –        checkCompletedNormally(g, v2);
1442 –    }}
1443 –
1444 –    /**
1499       * thenAcceptBoth result completes exceptionally if either source cancelled
1500       */
1501      public void testThenAcceptBoth_sourceCancelled() {
# Line 1453 | Line 1507 | public class CompletableFutureTest exten
1507      {
1508          final CompletableFuture<Integer> f = new CompletableFuture<>();
1509          final CompletableFuture<Integer> g = new CompletableFuture<>();
1510 <        final SubtractAction r = new SubtractAction();
1510 >        final SubtractAction r = new SubtractAction(m);
1511  
1512          (fFirst ? f : g).complete(v1);
1513          if (!createIncomplete)
# Line 1471 | Line 1525 | public class CompletableFutureTest exten
1525      }}
1526  
1527      /**
1528 <     * runAfterBoth result completes normally after normal
1475 <     * completion of sources
1528 >     * thenAcceptBoth result completes exceptionally if action does
1529       */
1530 <    public void testRunAfterBoth_normalCompletion1() {
1478 <        for (ExecutionMode m : ExecutionMode.values())
1479 <        for (Integer v1 : new Integer[] { 1, null })
1480 <        for (Integer v2 : new Integer[] { 2, null })
1481 <    {
1482 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1483 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1484 <        final Noop r = new Noop();
1485 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1486 <
1487 <        f.complete(v1);
1488 <        checkIncomplete(h);
1489 <        assertEquals(0, r.invocationCount);
1490 <        g.complete(v2);
1491 <
1492 <        checkCompletedNormally(h, null);
1493 <        assertEquals(1, r.invocationCount);
1494 <        checkCompletedNormally(f, v1);
1495 <        checkCompletedNormally(g, v2);
1496 <    }}
1497 <
1498 <    public void testRunAfterBoth_normalCompletion2() {
1499 <        for (ExecutionMode m : ExecutionMode.values())
1500 <        for (Integer v1 : new Integer[] { 1, null })
1501 <        for (Integer v2 : new Integer[] { 2, null })
1502 <    {
1503 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1504 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1505 <        final Noop r = new Noop();
1506 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1507 <
1508 <        g.complete(v2);
1509 <        checkIncomplete(h);
1510 <        assertEquals(0, r.invocationCount);
1511 <        f.complete(v1);
1512 <
1513 <        checkCompletedNormally(h, null);
1514 <        assertEquals(1, r.invocationCount);
1515 <        checkCompletedNormally(f, v1);
1516 <        checkCompletedNormally(g, v2);
1517 <    }}
1518 <
1519 <    public void testRunAfterBoth_normalCompletion3() {
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 Noop r = new Noop();
1538 >        final FailingBiConsumer r = new FailingBiConsumer(m);
1539 >        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1540  
1541 <        g.complete(v2);
1542 <        f.complete(v1);
1543 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1541 >        if (fFirst) {
1542 >            f.complete(v1);
1543 >            g.complete(v2);
1544 >        } else {
1545 >            g.complete(v2);
1546 >            f.complete(v1);
1547 >        }
1548  
1549 <        checkCompletedNormally(h, null);
1533 <        assertEquals(1, r.invocationCount);
1549 >        checkCompletedWithWrappedCFException(h);
1550          checkCompletedNormally(f, v1);
1551          checkCompletedNormally(g, v2);
1552      }}
1553  
1554 <    public void testRunAfterBoth_normalCompletion4() {
1554 >    /**
1555 >     * runAfterBoth result completes normally after normal
1556 >     * completion of sources
1557 >     */
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 1558 | Line 1586 | public class CompletableFutureTest exten
1586       * runAfterBoth result completes exceptionally after exceptional
1587       * completion of either source
1588       */
1589 <    public void testRunAfterBoth_exceptionalCompletion1() {
1562 <        for (ExecutionMode m : ExecutionMode.values())
1563 <        for (Integer v1 : new Integer[] { 1, null })
1564 <    {
1565 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1566 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1567 <        final Noop r = new Noop();
1568 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1569 <        final CFException ex = new CFException();
1570 <
1571 <        f.completeExceptionally(ex);
1572 <        checkIncomplete(h);
1573 <        g.complete(v1);
1574 <
1575 <        checkCompletedWithWrappedCFException(h, ex);
1576 <        checkCompletedWithWrappedCFException(f, ex);
1577 <        assertEquals(0, r.invocationCount);
1578 <        checkCompletedNormally(g, v1);
1579 <    }}
1580 <
1581 <    public void testRunAfterBoth_exceptionalCompletion2() {
1582 <        for (ExecutionMode m : ExecutionMode.values())
1583 <        for (Integer v1 : new Integer[] { 1, null })
1584 <    {
1585 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1586 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1587 <        final Noop r = new Noop();
1588 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1589 <        final CFException ex = new CFException();
1590 <
1591 <        g.completeExceptionally(ex);
1592 <        checkIncomplete(h);
1593 <        f.complete(v1);
1594 <
1595 <        checkCompletedWithWrappedCFException(h, ex);
1596 <        checkCompletedWithWrappedCFException(g, ex);
1597 <        assertEquals(0, r.invocationCount);
1598 <        checkCompletedNormally(f, v1);
1599 <    }}
1600 <
1601 <    public void testRunAfterBoth_exceptionalCompletion3() {
1602 <        for (ExecutionMode m : ExecutionMode.values())
1603 <        for (Integer v1 : new Integer[] { 1, null })
1604 <    {
1605 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1606 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1607 <        final Noop r = new Noop();
1608 <        final CFException ex = new CFException();
1609 <
1610 <        g.completeExceptionally(ex);
1611 <        f.complete(v1);
1612 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1613 <
1614 <        checkCompletedWithWrappedCFException(h, ex);
1615 <        checkCompletedWithWrappedCFException(g, ex);
1616 <        assertEquals(0, r.invocationCount);
1617 <        checkCompletedNormally(f, v1);
1618 <    }}
1619 <
1620 <    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<>();
1626 –        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);
1634 –        checkCompletedWithWrappedCFException(f, ex);
1610          assertEquals(0, r.invocationCount);
1611 <        checkCompletedNormally(g, v1);
1612 <    }}
1638 <
1639 <    /**
1640 <     * runAfterBoth result completes exceptionally if action does
1641 <     */
1642 <    public void testRunAfterBoth_actionFailed1() {
1643 <        for (ExecutionMode m : ExecutionMode.values())
1644 <        for (Integer v1 : new Integer[] { 1, null })
1645 <        for (Integer v2 : new Integer[] { 2, null })
1646 <    {
1647 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1648 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1649 <        final FailingRunnable r = new FailingRunnable();
1650 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1651 <
1652 <        f.complete(v1);
1653 <        checkIncomplete(h);
1654 <        g.complete(v2);
1655 <
1656 <        checkCompletedWithWrappedCFException(h);
1657 <        checkCompletedNormally(f, v1);
1658 <        checkCompletedNormally(g, v2);
1659 <    }}
1660 <
1661 <    public void testRunAfterBoth_actionFailed2() {
1662 <        for (ExecutionMode m : ExecutionMode.values())
1663 <        for (Integer v1 : new Integer[] { 1, null })
1664 <        for (Integer v2 : new Integer[] { 2, null })
1665 <    {
1666 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1667 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1668 <        final FailingRunnable r = new FailingRunnable();
1669 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1670 <
1671 <        g.complete(v2);
1672 <        checkIncomplete(h);
1673 <        f.complete(v1);
1674 <
1675 <        checkCompletedWithWrappedCFException(h);
1676 <        checkCompletedNormally(f, v1);
1677 <        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();
1691 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1627 >        final Noop r = new Noop(m);
1628  
1693 –        assertTrue(f.cancel(mayInterruptIfRunning));
1694 –        checkIncomplete(h);
1695 –        g.complete(v1);
1629  
1630 <        checkCompletedWithWrappedCancellationException(h);
1631 <        checkCancelled(f);
1632 <        assertEquals(0, r.invocationCount);
1700 <        checkCompletedNormally(g, v1);
1701 <    }}
1702 <
1703 <    public void testRunAfterBoth_sourceCancelled2() {
1704 <        for (ExecutionMode m : ExecutionMode.values())
1705 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1706 <        for (Integer v1 : new Integer[] { 1, null })
1707 <    {
1708 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1709 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1710 <        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);
1738 <        assertEquals(0, r.invocationCount);
1668 >        checkCompletedWithWrappedCFException(h1);
1669 >        checkCompletedWithWrappedCFException(h2);
1670          checkCompletedNormally(f, v1);
1671 <    }}
1741 <
1742 <    public void testRunAfterBoth_sourceCancelled4() {
1743 <        for (ExecutionMode m : ExecutionMode.values())
1744 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1745 <        for (Integer v1 : new Integer[] { 1, null })
1746 <    {
1747 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1748 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1749 <        final Noop r = new Noop();
1750 <
1751 <        assertTrue(f.cancel(mayInterruptIfRunning));
1752 <        g.complete(v1);
1753 <        final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1754 <
1755 <        checkCompletedWithWrappedCancellationException(h);
1756 <        checkCancelled(f);
1757 <        assertEquals(0, r.invocationCount);
1758 <        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();
1773 <        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();
1792 <        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));
1801 <        }}
1802 <
1803 <    public void testApplyToEither_normalCompletion3() {
1804 <        for (ExecutionMode m : ExecutionMode.values())
1805 <        for (Integer v1 : new Integer[] { 1, null })
1806 <        for (Integer v2 : new Integer[] { 2, null })
1807 <    {
1808 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1809 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1810 <        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  
1812 –        f.complete(v1);
1813 –        g.complete(v2);
1723          final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1724  
1725          checkCompletedNormally(f, v1);
# Line 1828 | 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<>();
1835 –        final IncFunction r = new IncFunction();
1836 –        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);
1840 <        checkCompletedWithWrappedCFException(h, ex);
1841 <        g.complete(v1);
1842 <
1843 <        assertEquals(0, r.invocationCount);
1844 <        checkCompletedNormally(g, v1);
1845 <        checkCompletedWithWrappedCFException(f, ex);
1846 <        checkCompletedWithWrappedCFException(h, ex);
1847 <    }}
1848 <
1849 <    public void testApplyToEither_exceptionalCompletion2() {
1850 <        for (ExecutionMode m : ExecutionMode.values())
1851 <        for (Integer v1 : new Integer[] { 1, null })
1852 <    {
1853 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1854 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1855 <        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  
1859 –        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
1883 –        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  
1892 –        checkCompletedWithWrappedCFException(g, ex);
1893 –        checkCompletedNormally(f, v1);
1894 –    }}
1895 –
1896 –    public void testApplyToEither_exceptionalCompletion4() {
1897 –        for (ExecutionMode m : ExecutionMode.values())
1898 –        for (Integer v1 : new Integer[] { 1, null })
1899 –    {
1900 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
1901 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
1902 –        final IncFunction r = new IncFunction();
1903 –        final CFException ex = new CFException();
1904 –
1905 –        f.completeExceptionally(ex);
1906 –        g.complete(v1);
1907 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1908 –
1909 –        // unspecified behavior
1910 –        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 1930 | 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 1947 | 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 1963 | 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();
1971 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1859 >        final IncFunction r = new IncFunction(m);
1860  
1861 <        assertTrue(f.cancel(mayInterruptIfRunning));
1974 <        checkCompletedWithWrappedCancellationException(h);
1975 <        g.complete(v1);
1976 <
1977 <        checkCancelled(f);
1978 <        assertEquals(0, r.invocationCount);
1979 <        checkCompletedNormally(g, v1);
1980 <        checkCompletedWithWrappedCancellationException(h);
1981 <    }}
1982 <
1983 <    public void testApplyToEither_sourceCancelled2() {
1984 <        for (ExecutionMode m : ExecutionMode.values())
1985 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1986 <        for (Integer v1 : new Integer[] { 1, null })
1987 <    {
1988 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1989 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1990 <        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  
1993 –        assertTrue(g.cancel(mayInterruptIfRunning));
1869          checkCompletedWithWrappedCancellationException(h);
1870 <        f.complete(v1);
1870 >        (!fFirst ? f : g).complete(v1);
1871  
1997 –        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
2017 –        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  
2026 –        checkCancelled(g);
2027 –        checkCompletedNormally(f, v1);
2028 –    }}
2029 –
2030 –    public void testApplyToEither_sourceCancelled4() {
2031 –        for (ExecutionMode m : ExecutionMode.values())
2032 –        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2033 –        for (Integer v1 : new Integer[] { 1, null })
2034 –    {
2035 –        final CompletableFuture<Integer> f = new CompletableFuture<>();
2036 –        final CompletableFuture<Integer> g = new CompletableFuture<>();
2037 –        final IncFunction r = new IncFunction();
2038 –
2039 –        assertTrue(f.cancel(mayInterruptIfRunning));
2040 –        g.complete(v1);
2041 –        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
2042 –
2043 –        // unspecified behavior
2044 –        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 2230 | 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 2247 | 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 2367 | 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 2388 | 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 2409 | 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 2431 | 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 2451 | 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 2471 | 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 2498 | 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 2529 | Line 2396 | public class CompletableFutureTest exten
2396      {
2397          final CompletableFuture<Integer> f = new CompletableFuture<>();
2398          final CompletableFuture<Integer> g = new CompletableFuture<>();
2399 <        final FailingRunnable r = new FailingRunnable();
2399 >        final FailingRunnable r = new FailingRunnable(m);
2400          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2401  
2402          f.complete(v1);
# Line 2546 | Line 2413 | public class CompletableFutureTest exten
2413      {
2414          final CompletableFuture<Integer> f = new CompletableFuture<>();
2415          final CompletableFuture<Integer> g = new CompletableFuture<>();
2416 <        final FailingRunnable r = new FailingRunnable();
2416 >        final FailingRunnable r = new FailingRunnable(m);
2417          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2418  
2419          g.complete(v2);
# Line 2566 | 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 2586 | 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 2606 | 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 2633 | 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 2662 | 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 2681 | 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 2702 | 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 2720 | 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);
2592 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2593          if (createIncomplete) {
2594              checkIncomplete(g);
2595              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2749 | 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 2763 | 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 2821 | 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 2894 | 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