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.54 by jsr166, Mon Jun 2 21:32:24 2014 UTC vs.
Revision 1.63 by jsr166, Fri Jun 6 16:54:16 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
323 >    abstract class CheckedAction {
324 >        int invocationCount = 0;
325 >        final ExecutionMode m;
326 >        CheckedAction(ExecutionMode m) { this.m = m; }
327 >        void invoked() {
328 >            m.checkExecutionMode();
329 >            assertEquals(0, invocationCount++);
330 >        }
331 >        void assertNotInvoked() { assertEquals(0, invocationCount); }
332 >        void assertInvoked() { assertEquals(1, invocationCount); }
333 >    }
334  
335 <    // A non-commutative function that handles and produces null values as well.
336 <    static Integer subtract(Integer x, Integer y) {
337 <        return (x == null && y == null) ? null :
338 <            ((x == null) ? 42 : x.intValue())
339 <            - ((y == null) ? 99 : y.intValue());
335 >    abstract class CheckedIntegerAction extends CheckedAction {
336 >        Integer value;
337 >        CheckedIntegerAction(ExecutionMode m) { super(m); }
338 >        void assertValue(Integer expected) {
339 >            assertInvoked();
340 >            assertEquals(expected, value);
341 >        }
342 >    }
343 >
344 >    class IntegerSupplier extends CheckedAction
345 >        implements Supplier<Integer>
346 >    {
347 >        final Integer value;
348 >        IntegerSupplier(ExecutionMode m, Integer value) {
349 >            super(m);
350 >            this.value = value;
351 >        }
352 >        public Integer get() {
353 >            invoked();
354 >            return value;
355 >        }
356      }
357  
358      // A function that handles and produces null values as well.
# Line 334 | Line 360 | public class CompletableFutureTest exten
360          return (x == null) ? null : x + 1;
361      }
362  
363 <    static final Supplier<Integer> supplyOne =
364 <        () -> Integer.valueOf(1);
365 <    static final Function<Integer, Integer> inc =
366 <        (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;
363 >    class IncAction extends CheckedIntegerAction
364 >        implements Consumer<Integer>
365 >    {
366 >        IncAction(ExecutionMode m) { super(m); }
367          public void accept(Integer x) {
368 <            invocationCount++;
368 >            invoked();
369              value = inc(x);
370          }
371      }
372 <    static final class IncFunction implements Function<Integer,Integer> {
373 <        int invocationCount = 0;
374 <        Integer value;
372 >
373 >    class IncFunction extends CheckedIntegerAction
374 >        implements Function<Integer,Integer>
375 >    {
376 >        IncFunction(ExecutionMode m) { super(m); }
377          public Integer apply(Integer x) {
378 <            invocationCount++;
378 >            invoked();
379              return value = inc(x);
380          }
381      }
382 <    static final class SubtractAction implements BiConsumer<Integer, Integer> {
383 <        int invocationCount = 0;
384 <        Integer value;
385 <        // Check this action was invoked exactly once when result is computed.
382 >
383 >    // Choose non-commutative actions for better coverage
384 >    // A non-commutative function that handles and produces null values as well.
385 >    static Integer subtract(Integer x, Integer y) {
386 >        return (x == null && y == null) ? null :
387 >            ((x == null) ? 42 : x.intValue())
388 >            - ((y == null) ? 99 : y.intValue());
389 >    }
390 >
391 >    class SubtractAction extends CheckedIntegerAction
392 >        implements BiConsumer<Integer, Integer>
393 >    {
394 >        SubtractAction(ExecutionMode m) { super(m); }
395          public void accept(Integer x, Integer y) {
396 <            invocationCount++;
396 >            invoked();
397              value = subtract(x, y);
398          }
399      }
400 <    static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
401 <        int invocationCount = 0;
402 <        Integer value;
403 <        // Check this action was invoked exactly once when result is computed.
400 >
401 >    class SubtractFunction extends CheckedIntegerAction
402 >        implements BiFunction<Integer, Integer, Integer>
403 >    {
404 >        SubtractFunction(ExecutionMode m) { super(m); }
405          public Integer apply(Integer x, Integer y) {
406 <            invocationCount++;
406 >            invoked();
407              return value = subtract(x, y);
408          }
409      }
410 <    static final class Noop implements Runnable {
411 <        int invocationCount = 0;
410 >
411 >    class Noop extends CheckedAction implements Runnable {
412 >        Noop(ExecutionMode m) { super(m); }
413          public void run() {
414 <            invocationCount++;
414 >            invoked();
415          }
416      }
417  
418 <    static final class FailingSupplier implements Supplier<Integer> {
419 <        int invocationCount = 0;
418 >    class FailingSupplier extends CheckedAction
419 >        implements Supplier<Integer>
420 >    {
421 >        FailingSupplier(ExecutionMode m) { super(m); }
422          public Integer get() {
423 <            invocationCount++;
423 >            invoked();
424              throw new CFException();
425          }
426      }
427 <    static final class FailingConsumer implements Consumer<Integer> {
428 <        int invocationCount = 0;
427 >
428 >    class FailingConsumer extends CheckedIntegerAction
429 >        implements Consumer<Integer>
430 >    {
431 >        FailingConsumer(ExecutionMode m) { super(m); }
432          public void accept(Integer x) {
433 <            invocationCount++;
433 >            invoked();
434 >            value = x;
435              throw new CFException();
436          }
437      }
438 <    static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
439 <        int invocationCount = 0;
438 >
439 >    class FailingBiConsumer extends CheckedIntegerAction
440 >        implements BiConsumer<Integer, Integer>
441 >    {
442 >        FailingBiConsumer(ExecutionMode m) { super(m); }
443          public void accept(Integer x, Integer y) {
444 <            invocationCount++;
444 >            invoked();
445 >            value = subtract(x, y);
446              throw new CFException();
447          }
448      }
449 <    static final class FailingFunction implements Function<Integer, Integer> {
450 <        int invocationCount = 0;
449 >
450 >    class FailingFunction extends CheckedIntegerAction
451 >        implements Function<Integer, Integer>
452 >    {
453 >        FailingFunction(ExecutionMode m) { super(m); }
454          public Integer apply(Integer x) {
455 <            invocationCount++;
455 >            invoked();
456 >            value = x;
457              throw new CFException();
458          }
459      }
460 <    static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
461 <        int invocationCount = 0;
460 >
461 >    class FailingBiFunction extends CheckedIntegerAction
462 >        implements BiFunction<Integer, Integer, Integer>
463 >    {
464 >        FailingBiFunction(ExecutionMode m) { super(m); }
465          public Integer apply(Integer x, Integer y) {
466 <            invocationCount++;
466 >            invoked();
467 >            value = subtract(x, y);
468              throw new CFException();
469          }
470      }
471 <    static final class FailingRunnable implements Runnable {
472 <        int invocationCount = 0;
471 >
472 >    class FailingRunnable extends CheckedAction implements Runnable {
473 >        FailingRunnable(ExecutionMode m) { super(m); }
474          public void run() {
475 <            invocationCount++;
475 >            invoked();
476              throw new CFException();
477          }
478      }
479  
480 <    static final class CompletableFutureInc
481 <        implements Function<Integer, CompletableFuture<Integer>> {
482 <        int invocationCount = 0;
480 >
481 >    class CompletableFutureInc extends CheckedIntegerAction
482 >        implements Function<Integer, CompletableFuture<Integer>>
483 >    {
484 >        CompletableFutureInc(ExecutionMode m) { super(m); }
485          public CompletableFuture<Integer> apply(Integer x) {
486 <            invocationCount++;
486 >            invoked();
487 >            value = x;
488              CompletableFuture<Integer> f = new CompletableFuture<>();
489              f.complete(inc(x));
490              return f;
491          }
492      }
493  
494 <    static final class FailingCompletableFutureFunction
495 <        implements Function<Integer, CompletableFuture<Integer>> {
496 <        int invocationCount = 0;
494 >    class FailingCompletableFutureFunction extends CheckedIntegerAction
495 >        implements Function<Integer, CompletableFuture<Integer>>
496 >    {
497 >        FailingCompletableFutureFunction(ExecutionMode m) { super(m); }
498          public CompletableFuture<Integer> apply(Integer x) {
499 <            invocationCount++;
499 >            invoked();
500 >            value = x;
501              throw new CFException();
502          }
503      }
504  
505      // Used for explicit executor tests
506      static final class ThreadExecutor implements Executor {
507 <        AtomicInteger count = new AtomicInteger(0);
507 >        final AtomicInteger count = new AtomicInteger(0);
508 >        static final ThreadGroup tg = new ThreadGroup("ThreadExecutor");
509 >        static boolean startedCurrentThread() {
510 >            return Thread.currentThread().getThreadGroup() == tg;
511 >        }
512  
513          public void execute(Runnable r) {
514              count.getAndIncrement();
515 <            new Thread(r).start();
515 >            new Thread(tg, r).start();
516          }
517      }
518  
519      /**
520       * Permits the testing of parallel code for the 3 different
521 <     * execution modes without repeating all the testing code.
521 >     * execution modes without copy/pasting all the test methods.
522       */
523      enum ExecutionMode {
524          DEFAULT {
525              public void checkExecutionMode() {
526 +                assertFalse(ThreadExecutor.startedCurrentThread());
527                  assertNull(ForkJoinTask.getPool());
528              }
529 +            public CompletableFuture<Void> runAsync(Runnable a) {
530 +                throw new UnsupportedOperationException();
531 +            }
532 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
533 +                throw new UnsupportedOperationException();
534 +            }
535              public <T> CompletableFuture<Void> thenRun
536                  (CompletableFuture<T> f, Runnable a) {
537                  return f.thenRun(a);
# Line 531 | Line 600 | public class CompletableFutureTest exten
600                  assertSame(ForkJoinPool.commonPool(),
601                             ForkJoinTask.getPool());
602              }
603 +            public CompletableFuture<Void> runAsync(Runnable a) {
604 +                return CompletableFuture.runAsync(a);
605 +            }
606 +            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
607 +                return CompletableFuture.supplyAsync(a);
608 +            }
609              public <T> CompletableFuture<Void> thenRun
610                  (CompletableFuture<T> f, Runnable a) {
611                  return f.thenRunAsync(a);
# Line 596 | Line 671 | public class CompletableFutureTest exten
671  
672          EXECUTOR {
673              public void checkExecutionMode() {
674 <                //TODO
674 >                assertTrue(ThreadExecutor.startedCurrentThread());
675 >            }
676 >            public CompletableFuture<Void> runAsync(Runnable a) {
677 >                return CompletableFuture.runAsync(a, new ThreadExecutor());
678 >            }
679 >            public <U> CompletableFuture<U> supplyAsync(Supplier<U> a) {
680 >                return CompletableFuture.supplyAsync(a, new ThreadExecutor());
681              }
682              public <T> CompletableFuture<Void> thenRun
683                  (CompletableFuture<T> f, Runnable a) {
# Line 662 | Line 743 | public class CompletableFutureTest exten
743          };
744  
745          public abstract void checkExecutionMode();
746 +        public abstract CompletableFuture<Void> runAsync(Runnable a);
747 +        public abstract <U> CompletableFuture<U> supplyAsync(Supplier<U> a);
748          public abstract <T> CompletableFuture<Void> thenRun
749              (CompletableFuture<T> f, Runnable a);
750          public abstract <T> CompletableFuture<Void> thenAccept
# Line 740 | Line 823 | public class CompletableFutureTest exten
823          if (!createIncomplete) f.completeExceptionally(ex);
824          final CompletableFuture<Integer> g = f.exceptionally
825              ((Throwable t) -> {
826 +                ExecutionMode.DEFAULT.checkExecutionMode();
827                  threadAssertSame(t, ex);
828                  a.getAndIncrement();
829                  return v1;
# Line 761 | Line 845 | public class CompletableFutureTest exten
845          if (!createIncomplete) f.completeExceptionally(ex1);
846          final CompletableFuture<Integer> g = f.exceptionally
847              ((Throwable t) -> {
848 +                ExecutionMode.DEFAULT.checkExecutionMode();
849                  threadAssertSame(t, ex1);
850                  a.getAndIncrement();
851                  throw ex2;
# Line 786 | Line 871 | public class CompletableFutureTest exten
871          final CompletableFuture<Integer> g = m.handle
872              (f,
873               (Integer x, Throwable t) -> {
874 +                m.checkExecutionMode();
875                  threadAssertSame(x, v1);
876                  threadAssertNull(t);
877                  a.getAndIncrement();
# Line 814 | Line 900 | public class CompletableFutureTest exten
900          final CompletableFuture<Integer> g = m.handle
901              (f,
902               (Integer x, Throwable t) -> {
903 +                m.checkExecutionMode();
904                  threadAssertNull(x);
905                  threadAssertSame(t, ex);
906                  a.getAndIncrement();
# Line 842 | Line 929 | public class CompletableFutureTest exten
929          final CompletableFuture<Integer> g = m.handle
930              (f,
931               (Integer x, Throwable t) -> {
932 +                m.checkExecutionMode();
933                  threadAssertNull(x);
934                  threadAssertTrue(t instanceof CancellationException);
935                  a.getAndIncrement();
# Line 869 | Line 957 | public class CompletableFutureTest exten
957          final CompletableFuture<Integer> g = m.handle
958              (f,
959               (Integer x, Throwable t) -> {
960 +                m.checkExecutionMode();
961                  threadAssertNull(x);
962                  threadAssertSame(ex1, t);
963                  a.getAndIncrement();
# Line 893 | Line 982 | public class CompletableFutureTest exten
982          final CompletableFuture<Integer> g = m.handle
983              (f,
984               (Integer x, Throwable t) -> {
985 +                m.checkExecutionMode();
986                  threadAssertSame(x, v1);
987                  threadAssertNull(t);
988                  a.getAndIncrement();
# Line 908 | Line 998 | public class CompletableFutureTest exten
998      /**
999       * runAsync completes after running Runnable
1000       */
1001 <    public void testRunAsync() {
1002 <        Noop r = new Noop();
1003 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
1004 <        assertNull(f.join());
1005 <        assertEquals(1, r.invocationCount);
1006 <        checkCompletedNormally(f, null);
1007 <    }
1008 <
1009 <    /**
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);
1001 >    public void testRunAsync_normalCompletion() {
1002 >        ExecutionMode[] executionModes = {
1003 >            ExecutionMode.ASYNC,
1004 >            ExecutionMode.EXECUTOR,
1005 >        };
1006 >        for (ExecutionMode m : executionModes)
1007 >    {
1008 >        final Noop r = new Noop(m);
1009 >        final CompletableFuture<Void> f = m.runAsync(r);
1010          assertNull(f.join());
927        assertEquals(1, r.invocationCount);
1011          checkCompletedNormally(f, null);
1012 <        assertEquals(1, exec.count.get());
1013 <    }
1012 >        r.assertInvoked();
1013 >    }}
1014  
1015      /**
1016       * failing runAsync completes exceptionally after running Runnable
1017       */
1018 <    public void testRunAsync3() {
1019 <        FailingRunnable r = new FailingRunnable();
1020 <        CompletableFuture<Void> f = CompletableFuture.runAsync(r);
1018 >    public void testRunAsync_exceptionalCompletion() {
1019 >        ExecutionMode[] executionModes = {
1020 >            ExecutionMode.ASYNC,
1021 >            ExecutionMode.EXECUTOR,
1022 >        };
1023 >        for (ExecutionMode m : executionModes)
1024 >    {
1025 >        final FailingRunnable r = new FailingRunnable(m);
1026 >        final CompletableFuture<Void> f = m.runAsync(r);
1027          checkCompletedWithWrappedCFException(f);
1028 <        assertEquals(1, r.invocationCount);
1029 <    }
1028 >        r.assertInvoked();
1029 >    }}
1030  
1031      /**
1032       * supplyAsync completes with result of supplier
1033       */
1034 <    public void testSupplyAsync() {
1035 <        CompletableFuture<Integer> f;
1036 <        f = CompletableFuture.supplyAsync(supplyOne);
1037 <        assertEquals(f.join(), one);
1038 <        checkCompletedNormally(f, one);
1039 <    }
1040 <
1041 <    /**
1042 <     * supplyAsync with executor completes with result of supplier
1043 <     */
1044 <    public void testSupplyAsync2() {
1045 <        CompletableFuture<Integer> f;
1046 <        f = CompletableFuture.supplyAsync(supplyOne, new ThreadExecutor());
1047 <        assertEquals(f.join(), one);
959 <        checkCompletedNormally(f, one);
960 <    }
1034 >    public void testSupplyAsync_normalCompletion() {
1035 >        ExecutionMode[] executionModes = {
1036 >            ExecutionMode.ASYNC,
1037 >            ExecutionMode.EXECUTOR,
1038 >        };
1039 >        for (ExecutionMode m : executionModes)
1040 >        for (Integer v1 : new Integer[] { 1, null })
1041 >    {
1042 >        final IntegerSupplier r = new IntegerSupplier(m, v1);
1043 >        final CompletableFuture<Integer> f = m.supplyAsync(r);
1044 >        assertSame(v1, f.join());
1045 >        checkCompletedNormally(f, v1);
1046 >        r.assertInvoked();
1047 >    }}
1048  
1049      /**
1050       * Failing supplyAsync completes exceptionally
1051       */
1052 <    public void testSupplyAsync3() {
1053 <        FailingSupplier r = new FailingSupplier();
1054 <        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
1052 >    public void testSupplyAsync_exceptionalCompletion() {
1053 >        ExecutionMode[] executionModes = {
1054 >            ExecutionMode.ASYNC,
1055 >            ExecutionMode.EXECUTOR,
1056 >        };
1057 >        for (ExecutionMode m : executionModes)
1058 >    {
1059 >        FailingSupplier r = new FailingSupplier(m);
1060 >        CompletableFuture<Integer> f = m.supplyAsync(r);
1061          checkCompletedWithWrappedCFException(f);
1062 <        assertEquals(1, r.invocationCount);
1063 <    }
1062 >        r.assertInvoked();
1063 >    }}
1064  
1065      // seq completion methods
1066  
# Line 980 | Line 1073 | public class CompletableFutureTest exten
1073          for (Integer v1 : new Integer[] { 1, null })
1074      {
1075          final CompletableFuture<Integer> f = new CompletableFuture<>();
1076 <        final Noop r = new Noop();
1076 >        final Noop r = new Noop(m);
1077          if (!createIncomplete) f.complete(v1);
1078          final CompletableFuture<Void> g = m.thenRun(f, r);
1079          if (createIncomplete) {
# Line 990 | Line 1083 | public class CompletableFutureTest exten
1083  
1084          checkCompletedNormally(g, null);
1085          checkCompletedNormally(f, v1);
1086 <        assertEquals(1, r.invocationCount);
1086 >        r.assertInvoked();
1087      }}
1088  
1089      /**
# Line 1003 | Line 1096 | public class CompletableFutureTest exten
1096      {
1097          final CFException ex = new CFException();
1098          final CompletableFuture<Integer> f = new CompletableFuture<>();
1099 <        final Noop r = new Noop();
1099 >        final Noop r = new Noop(m);
1100          if (!createIncomplete) f.completeExceptionally(ex);
1101          final CompletableFuture<Void> g = m.thenRun(f, r);
1102          if (createIncomplete) {
# Line 1013 | Line 1106 | public class CompletableFutureTest exten
1106  
1107          checkCompletedWithWrappedCFException(g, ex);
1108          checkCompletedWithWrappedCFException(f, ex);
1109 <        assertEquals(0, r.invocationCount);
1109 >        r.assertNotInvoked();
1110      }}
1111  
1112      /**
# Line 1025 | Line 1118 | public class CompletableFutureTest exten
1118          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1119      {
1120          final CompletableFuture<Integer> f = new CompletableFuture<>();
1121 <        final Noop r = new Noop();
1121 >        final Noop r = new Noop(m);
1122          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1123 <        final CompletableFuture<Void> g = f.thenRun(r);
1123 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1124          if (createIncomplete) {
1125              checkIncomplete(g);
1126              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1035 | Line 1128 | public class CompletableFutureTest exten
1128  
1129          checkCompletedWithWrappedCancellationException(g);
1130          checkCancelled(f);
1131 <        assertEquals(0, r.invocationCount);
1131 >        r.assertNotInvoked();
1132      }}
1133  
1134      /**
# Line 1047 | Line 1140 | public class CompletableFutureTest exten
1140          for (Integer v1 : new Integer[] { 1, null })
1141      {
1142          final CompletableFuture<Integer> f = new CompletableFuture<>();
1143 <        final FailingRunnable r = new FailingRunnable();
1143 >        final FailingRunnable r = new FailingRunnable(m);
1144          if (!createIncomplete) f.complete(v1);
1145 <        final CompletableFuture<Void> g = f.thenRun(r);
1145 >        final CompletableFuture<Void> g = m.thenRun(f, r);
1146          if (createIncomplete) {
1147              checkIncomplete(g);
1148              f.complete(v1);
# Line 1068 | Line 1161 | public class CompletableFutureTest exten
1161          for (Integer v1 : new Integer[] { 1, null })
1162      {
1163          final CompletableFuture<Integer> f = new CompletableFuture<>();
1164 <        final IncFunction r = new IncFunction();
1164 >        final IncFunction r = new IncFunction(m);
1165          if (!createIncomplete) f.complete(v1);
1166          final CompletableFuture<Integer> g = m.thenApply(f, r);
1167          if (createIncomplete) {
# Line 1078 | Line 1171 | public class CompletableFutureTest exten
1171  
1172          checkCompletedNormally(g, inc(v1));
1173          checkCompletedNormally(f, v1);
1174 <        assertEquals(1, r.invocationCount);
1174 >        r.assertInvoked();
1175      }}
1176  
1177      /**
# Line 1091 | Line 1184 | public class CompletableFutureTest exten
1184      {
1185          final CFException ex = new CFException();
1186          final CompletableFuture<Integer> f = new CompletableFuture<>();
1187 <        final IncFunction r = new IncFunction();
1187 >        final IncFunction r = new IncFunction(m);
1188          if (!createIncomplete) f.completeExceptionally(ex);
1189          final CompletableFuture<Integer> g = m.thenApply(f, r);
1190          if (createIncomplete) {
# Line 1101 | Line 1194 | public class CompletableFutureTest exten
1194  
1195          checkCompletedWithWrappedCFException(g, ex);
1196          checkCompletedWithWrappedCFException(f, ex);
1197 <        assertEquals(0, r.invocationCount);
1197 >        r.assertNotInvoked();
1198      }}
1199  
1200      /**
# Line 1113 | Line 1206 | public class CompletableFutureTest exten
1206          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1207      {
1208          final CompletableFuture<Integer> f = new CompletableFuture<>();
1209 <        final IncFunction r = new IncFunction();
1209 >        final IncFunction r = new IncFunction(m);
1210          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1211 <        final CompletableFuture<Integer> g = f.thenApply(r);
1211 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1212          if (createIncomplete) {
1213              checkIncomplete(g);
1214              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 1123 | Line 1216 | public class CompletableFutureTest exten
1216  
1217          checkCompletedWithWrappedCancellationException(g);
1218          checkCancelled(f);
1219 <        assertEquals(0, r.invocationCount);
1219 >        r.assertNotInvoked();
1220      }}
1221  
1222      /**
# Line 1135 | Line 1228 | public class CompletableFutureTest exten
1228          for (Integer v1 : new Integer[] { 1, null })
1229      {
1230          final CompletableFuture<Integer> f = new CompletableFuture<>();
1231 <        final FailingFunction r = new FailingFunction();
1231 >        final FailingFunction r = new FailingFunction(m);
1232          if (!createIncomplete) f.complete(v1);
1233 <        final CompletableFuture<Integer> g = f.thenApply(r);
1233 >        final CompletableFuture<Integer> g = m.thenApply(f, r);
1234          if (createIncomplete) {
1235              checkIncomplete(g);
1236              f.complete(v1);
# Line 1156 | Line 1249 | public class CompletableFutureTest exten
1249          for (Integer v1 : new Integer[] { 1, null })
1250      {
1251          final CompletableFuture<Integer> f = new CompletableFuture<>();
1252 <        final IncAction r = new IncAction();
1252 >        final IncAction r = new IncAction(m);
1253          if (!createIncomplete) f.complete(v1);
1254          final CompletableFuture<Void> g = m.thenAccept(f, r);
1255          if (createIncomplete) {
# Line 1166 | Line 1259 | public class CompletableFutureTest exten
1259  
1260          checkCompletedNormally(g, null);
1261          checkCompletedNormally(f, v1);
1262 <        assertEquals(1, r.invocationCount);
1263 <        assertEquals(inc(v1), r.value);
1262 >        r.assertInvoked();
1263 >        r.assertValue(inc(v1));
1264      }}
1265  
1266      /**
# Line 1180 | Line 1273 | public class CompletableFutureTest exten
1273      {
1274          final CFException ex = new CFException();
1275          final CompletableFuture<Integer> f = new CompletableFuture<>();
1276 <        final IncAction r = new IncAction();
1276 >        final IncAction r = new IncAction(m);
1277          if (!createIncomplete) f.completeExceptionally(ex);
1278          final CompletableFuture<Void> g = m.thenAccept(f, r);
1279          if (createIncomplete) {
# Line 1190 | Line 1283 | public class CompletableFutureTest exten
1283  
1284          checkCompletedWithWrappedCFException(g, ex);
1285          checkCompletedWithWrappedCFException(f, ex);
1286 <        assertEquals(0, r.invocationCount);
1286 >        r.assertNotInvoked();
1287      }}
1288  
1289      /**
1290 <     * thenAccept result completes exceptionally if action does
1290 >     * thenAccept result completes exceptionally if source cancelled
1291       */
1292 <    public void testThenAccept_actionFailed() {
1292 >    public void testThenAccept_sourceCancelled() {
1293          for (ExecutionMode m : ExecutionMode.values())
1294          for (boolean createIncomplete : new boolean[] { true, false })
1295 <        for (Integer v1 : new Integer[] { 1, null })
1295 >        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1296      {
1297          final CompletableFuture<Integer> f = new CompletableFuture<>();
1298 <        final FailingConsumer r = new FailingConsumer();
1299 <        if (!createIncomplete) f.complete(v1);
1300 <        final CompletableFuture<Void> g = f.thenAccept(r);
1298 >        final IncAction r = new IncAction(m);
1299 >        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1300 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1301          if (createIncomplete) {
1302              checkIncomplete(g);
1303 <            f.complete(v1);
1303 >            assertTrue(f.cancel(mayInterruptIfRunning));
1304          }
1305  
1306 <        checkCompletedWithWrappedCFException(g);
1307 <        checkCompletedNormally(f, v1);
1306 >        checkCompletedWithWrappedCancellationException(g);
1307 >        checkCancelled(f);
1308 >        r.assertNotInvoked();
1309      }}
1310  
1311      /**
1312 <     * thenAccept result completes exceptionally if source cancelled
1312 >     * thenAccept result completes exceptionally if action does
1313       */
1314 <    public void testThenAccept_sourceCancelled() {
1314 >    public void testThenAccept_actionFailed() {
1315          for (ExecutionMode m : ExecutionMode.values())
1316          for (boolean createIncomplete : new boolean[] { true, false })
1317 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1317 >        for (Integer v1 : new Integer[] { 1, null })
1318      {
1319          final CompletableFuture<Integer> f = new CompletableFuture<>();
1320 <        final IncAction r = new IncAction();
1321 <        if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1322 <        final CompletableFuture<Void> g = f.thenAccept(r);
1320 >        final FailingConsumer r = new FailingConsumer(m);
1321 >        if (!createIncomplete) f.complete(v1);
1322 >        final CompletableFuture<Void> g = m.thenAccept(f, r);
1323          if (createIncomplete) {
1324              checkIncomplete(g);
1325 <            assertTrue(f.cancel(mayInterruptIfRunning));
1325 >            f.complete(v1);
1326          }
1327  
1328 <        checkCompletedWithWrappedCancellationException(g);
1329 <        checkCancelled(f);
1236 <        assertEquals(0, r.invocationCount);
1328 >        checkCompletedWithWrappedCFException(g);
1329 >        checkCompletedNormally(f, v1);
1330      }}
1331  
1332      /**
# Line 1249 | Line 1342 | public class CompletableFutureTest exten
1342      {
1343          final CompletableFuture<Integer> f = new CompletableFuture<>();
1344          final CompletableFuture<Integer> g = new CompletableFuture<>();
1345 <        final SubtractFunction r = new SubtractFunction();
1345 >        final SubtractFunction r = new SubtractFunction(m);
1346  
1347          if (fFirst) f.complete(v1); else g.complete(v2);
1348          if (!createIncomplete)
# Line 1257 | Line 1350 | public class CompletableFutureTest exten
1350          final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1351          if (createIncomplete) {
1352              checkIncomplete(h);
1353 <            assertEquals(0, r.invocationCount);
1353 >            r.assertNotInvoked();
1354              if (!fFirst) f.complete(v1); else g.complete(v2);
1355          }
1356  
1357          checkCompletedNormally(h, subtract(v1, v2));
1358          checkCompletedNormally(f, v1);
1359          checkCompletedNormally(g, v2);
1360 <        assertEquals(1, r.invocationCount);
1360 >        r.assertInvoked();
1361      }}
1362  
1363      /**
# Line 1280 | Line 1373 | public class CompletableFutureTest exten
1373          final CompletableFuture<Integer> f = new CompletableFuture<>();
1374          final CompletableFuture<Integer> g = new CompletableFuture<>();
1375          final CFException ex = new CFException();
1376 <        final SubtractFunction r = new SubtractFunction();
1376 >        final SubtractFunction r = new SubtractFunction(m);
1377  
1378          (fFirst ? f : g).complete(v1);
1379          if (!createIncomplete)
# Line 1292 | Line 1385 | public class CompletableFutureTest exten
1385          }
1386  
1387          checkCompletedWithWrappedCFException(h, ex);
1388 <        assertEquals(0, r.invocationCount);
1388 >        r.assertNotInvoked();
1389          checkCompletedNormally(fFirst ? f : g, v1);
1390          checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1391      }}
1392  
1393      /**
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    /**
1394       * thenCombine result completes exceptionally if either source cancelled
1395       */
1396      public void testThenCombine_sourceCancelled() {
# Line 1336 | Line 1402 | public class CompletableFutureTest exten
1402      {
1403          final CompletableFuture<Integer> f = new CompletableFuture<>();
1404          final CompletableFuture<Integer> g = new CompletableFuture<>();
1405 <        final SubtractFunction r = new SubtractFunction();
1405 >        final SubtractFunction r = new SubtractFunction(m);
1406  
1407          (fFirst ? f : g).complete(v1);
1408          if (!createIncomplete)
# Line 1349 | Line 1415 | public class CompletableFutureTest exten
1415  
1416          checkCompletedWithWrappedCancellationException(h);
1417          checkCancelled(!fFirst ? f : g);
1418 <        assertEquals(0, r.invocationCount);
1418 >        r.assertNotInvoked();
1419          checkCompletedNormally(fFirst ? f : g, v1);
1420      }}
1421  
1422      /**
1423 +     * thenCombine result completes exceptionally if action does
1424 +     */
1425 +    public void testThenCombine_actionFailed() {
1426 +        for (ExecutionMode m : ExecutionMode.values())
1427 +        for (boolean fFirst : new boolean[] { true, false })
1428 +        for (Integer v1 : new Integer[] { 1, null })
1429 +        for (Integer v2 : new Integer[] { 2, null })
1430 +    {
1431 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1432 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1433 +        final FailingBiFunction r = new FailingBiFunction(m);
1434 +        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1435 +
1436 +        if (fFirst) {
1437 +            f.complete(v1);
1438 +            g.complete(v2);
1439 +        } else {
1440 +            g.complete(v2);
1441 +            f.complete(v1);
1442 +        }
1443 +
1444 +        checkCompletedWithWrappedCFException(h);
1445 +        checkCompletedNormally(f, v1);
1446 +        checkCompletedNormally(g, v2);
1447 +    }}
1448 +
1449 +    /**
1450       * thenAcceptBoth result completes normally after normal
1451       * completion of sources
1452       */
# Line 1366 | Line 1459 | public class CompletableFutureTest exten
1459      {
1460          final CompletableFuture<Integer> f = new CompletableFuture<>();
1461          final CompletableFuture<Integer> g = new CompletableFuture<>();
1462 <        final SubtractAction r = new SubtractAction();
1462 >        final SubtractAction r = new SubtractAction(m);
1463  
1464          if (fFirst) f.complete(v1); else g.complete(v2);
1465          if (!createIncomplete)
# Line 1374 | Line 1467 | public class CompletableFutureTest exten
1467          final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1468          if (createIncomplete) {
1469              checkIncomplete(h);
1470 <            assertEquals(0, r.invocationCount);
1470 >            r.assertNotInvoked();
1471              if (!fFirst) f.complete(v1); else g.complete(v2);
1472          }
1473  
1474          checkCompletedNormally(h, null);
1475 <        assertEquals(subtract(v1, v2), r.value);
1475 >        r.assertValue(subtract(v1, v2));
1476          checkCompletedNormally(f, v1);
1477          checkCompletedNormally(g, v2);
1478      }}
# Line 1397 | Line 1490 | public class CompletableFutureTest exten
1490          final CompletableFuture<Integer> f = new CompletableFuture<>();
1491          final CompletableFuture<Integer> g = new CompletableFuture<>();
1492          final CFException ex = new CFException();
1493 <        final SubtractAction r = new SubtractAction();
1493 >        final SubtractAction r = new SubtractAction(m);
1494  
1495          (fFirst ? f : g).complete(v1);
1496          if (!createIncomplete)
# Line 1409 | Line 1502 | public class CompletableFutureTest exten
1502          }
1503  
1504          checkCompletedWithWrappedCFException(h, ex);
1505 <        assertEquals(0, r.invocationCount);
1505 >        r.assertNotInvoked();
1506          checkCompletedNormally(fFirst ? f : g, v1);
1507          checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1508      }}
1509  
1510      /**
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    /**
1511       * thenAcceptBoth result completes exceptionally if either source cancelled
1512       */
1513      public void testThenAcceptBoth_sourceCancelled() {
# Line 1453 | Line 1519 | public class CompletableFutureTest exten
1519      {
1520          final CompletableFuture<Integer> f = new CompletableFuture<>();
1521          final CompletableFuture<Integer> g = new CompletableFuture<>();
1522 <        final SubtractAction r = new SubtractAction();
1522 >        final SubtractAction r = new SubtractAction(m);
1523  
1524          (fFirst ? f : g).complete(v1);
1525          if (!createIncomplete)
# Line 1466 | Line 1532 | public class CompletableFutureTest exten
1532  
1533          checkCompletedWithWrappedCancellationException(h);
1534          checkCancelled(!fFirst ? f : g);
1535 <        assertEquals(0, r.invocationCount);
1535 >        r.assertNotInvoked();
1536          checkCompletedNormally(fFirst ? f : g, v1);
1537      }}
1538  
1539      /**
1540 +     * thenAcceptBoth result completes exceptionally if action does
1541 +     */
1542 +    public void testThenAcceptBoth_actionFailed() {
1543 +        for (ExecutionMode m : ExecutionMode.values())
1544 +        for (boolean fFirst : new boolean[] { true, false })
1545 +        for (Integer v1 : new Integer[] { 1, null })
1546 +        for (Integer v2 : new Integer[] { 2, null })
1547 +    {
1548 +        final CompletableFuture<Integer> f = new CompletableFuture<>();
1549 +        final CompletableFuture<Integer> g = new CompletableFuture<>();
1550 +        final FailingBiConsumer r = new FailingBiConsumer(m);
1551 +        final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1552 +
1553 +        if (fFirst) {
1554 +            f.complete(v1);
1555 +            g.complete(v2);
1556 +        } else {
1557 +            g.complete(v2);
1558 +            f.complete(v1);
1559 +        }
1560 +
1561 +        checkCompletedWithWrappedCFException(h);
1562 +        checkCompletedNormally(f, v1);
1563 +        checkCompletedNormally(g, v2);
1564 +    }}
1565 +
1566 +    /**
1567       * runAfterBoth result completes normally after normal
1568       * completion of sources
1569       */
# Line 1483 | Line 1576 | public class CompletableFutureTest exten
1576      {
1577          final CompletableFuture<Integer> f = new CompletableFuture<>();
1578          final CompletableFuture<Integer> g = new CompletableFuture<>();
1579 <        final Noop r = new Noop();
1579 >        final Noop r = new Noop(m);
1580  
1581          if (fFirst) f.complete(v1); else g.complete(v2);
1582          if (!createIncomplete)
# Line 1491 | Line 1584 | public class CompletableFutureTest exten
1584          final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1585          if (createIncomplete) {
1586              checkIncomplete(h);
1587 <            assertEquals(0, r.invocationCount);
1587 >            r.assertNotInvoked();
1588              if (!fFirst) f.complete(v1); else g.complete(v2);
1589          }
1590  
1591          checkCompletedNormally(h, null);
1592 <        assertEquals(1, r.invocationCount);
1592 >        r.assertInvoked();
1593          checkCompletedNormally(f, v1);
1594          checkCompletedNormally(g, v2);
1595      }}
# Line 1514 | Line 1607 | public class CompletableFutureTest exten
1607          final CompletableFuture<Integer> f = new CompletableFuture<>();
1608          final CompletableFuture<Integer> g = new CompletableFuture<>();
1609          final CFException ex = new CFException();
1610 <        final Noop r = new Noop();
1610 >        final Noop r = new Noop(m);
1611  
1612          (fFirst ? f : g).complete(v1);
1613          if (!createIncomplete)
# Line 1526 | Line 1619 | public class CompletableFutureTest exten
1619          }
1620  
1621          checkCompletedWithWrappedCFException(h, ex);
1622 <        assertEquals(0, r.invocationCount);
1622 >        r.assertNotInvoked();
1623          checkCompletedNormally(fFirst ? f : g, v1);
1624          checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
1625      }}
1626  
1627      /**
1535     * runAfterBoth result completes exceptionally if action does
1536     */
1537    public void testRunAfterBoth_actionFailed() {
1538        for (ExecutionMode m : ExecutionMode.values())
1539        for (boolean fFirst : new boolean[] { true, false })
1540        for (Integer v1 : new Integer[] { 1, null })
1541        for (Integer v2 : new Integer[] { 2, null })
1542    {
1543        final CompletableFuture<Integer> f = new CompletableFuture<>();
1544        final CompletableFuture<Integer> g = new CompletableFuture<>();
1545        final FailingRunnable r = new FailingRunnable();
1546
1547        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r);
1548        if (fFirst) {
1549            f.complete(v1);
1550            g.complete(v2);
1551        } else {
1552            g.complete(v2);
1553            f.complete(v1);
1554        }
1555        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r);
1556
1557        checkCompletedWithWrappedCFException(h1);
1558        checkCompletedWithWrappedCFException(h2);
1559        checkCompletedNormally(f, v1);
1560        checkCompletedNormally(g, v2);
1561    }}
1562
1563    /**
1628       * runAfterBoth result completes exceptionally if either source cancelled
1629       */
1630      public void testRunAfterBoth_sourceCancelled() {
# Line 1572 | Line 1636 | public class CompletableFutureTest exten
1636      {
1637          final CompletableFuture<Integer> f = new CompletableFuture<>();
1638          final CompletableFuture<Integer> g = new CompletableFuture<>();
1639 <        final Noop r = new Noop();
1639 >        final Noop r = new Noop(m);
1640  
1641  
1642          (fFirst ? f : g).complete(v1);
# Line 1586 | Line 1650 | public class CompletableFutureTest exten
1650  
1651          checkCompletedWithWrappedCancellationException(h);
1652          checkCancelled(!fFirst ? f : g);
1653 <        assertEquals(0, r.invocationCount);
1653 >        r.assertNotInvoked();
1654          checkCompletedNormally(fFirst ? f : g, v1);
1655      }}
1656  
1657      /**
1658 <     * applyToEither result completes normally after normal completion
1595 <     * of either source
1658 >     * runAfterBoth result completes exceptionally if action does
1659       */
1660 <    public void testApplyToEither_normalCompletion() {
1598 <        for (ExecutionMode m : ExecutionMode.values())
1599 <        for (boolean createIncomplete : new boolean[] { true, false })
1600 <        for (boolean fFirst : new boolean[] { true, false })
1601 <        for (Integer v1 : new Integer[] { 1, null })
1602 <        for (Integer v2 : new Integer[] { 2, null })
1603 <    {
1604 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1605 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1606 <        final IncFunction r = new IncFunction();
1607 <
1608 <        if (!createIncomplete)
1609 <            if (fFirst) f.complete(v1); else g.complete(v2);
1610 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1611 <        if (createIncomplete) {
1612 <            checkIncomplete(h);
1613 <            assertEquals(0, r.invocationCount);
1614 <            if (fFirst) f.complete(v1); else g.complete(v2);
1615 <        }
1616 <        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1617 <        if (!fFirst) f.complete(v1); else g.complete(v2);
1618 <
1619 <        checkCompletedNormally(f, v1);
1620 <        checkCompletedNormally(g, v2);
1621 <        checkCompletedNormally(h, inc(fFirst ? v1 : v2));
1622 <    }}
1623 <
1624 <    public void testApplyToEither_normalCompletionBothAvailable() {
1660 >    public void testRunAfterBoth_actionFailed() {
1661          for (ExecutionMode m : ExecutionMode.values())
1662          for (boolean fFirst : new boolean[] { true, false })
1663          for (Integer v1 : new Integer[] { 1, null })
# Line 1629 | Line 1665 | public class CompletableFutureTest exten
1665      {
1666          final CompletableFuture<Integer> f = new CompletableFuture<>();
1667          final CompletableFuture<Integer> g = new CompletableFuture<>();
1668 <        final IncFunction r = new IncFunction();
1668 >        final FailingRunnable r1 = new FailingRunnable(m);
1669 >        final FailingRunnable r2 = new FailingRunnable(m);
1670  
1671 +        CompletableFuture<Void> h1 = m.runAfterBoth(f, g, r1);
1672          if (fFirst) {
1673              f.complete(v1);
1674              g.complete(v2);
# Line 1638 | Line 1676 | public class CompletableFutureTest exten
1676              g.complete(v2);
1677              f.complete(v1);
1678          }
1679 +        CompletableFuture<Void> h2 = m.runAfterBoth(f, g, r2);
1680  
1681 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1682 <
1681 >        checkCompletedWithWrappedCFException(h1);
1682 >        checkCompletedWithWrappedCFException(h2);
1683          checkCompletedNormally(f, v1);
1684          checkCompletedNormally(g, v2);
1646
1647        // unspecified behavior
1648        assertTrue(Objects.equals(h.join(), inc(v1)) ||
1649                   Objects.equals(h.join(), inc(v2)));
1650        assertEquals(1, r.invocationCount);
1685      }}
1686  
1687      /**
1688 <     * applyToEither result completes exceptionally after exceptional
1689 <     * completion of either source
1688 >     * applyToEither result completes normally after normal completion
1689 >     * of either source
1690       */
1691 <    public void testApplyToEither_exceptionalCompletion1() {
1691 >    public void testApplyToEither_normalCompletion() {
1692          for (ExecutionMode m : ExecutionMode.values())
1659        for (boolean createIncomplete : new boolean[] { true, false })
1660        for (boolean fFirst : new boolean[] { true, false })
1693          for (Integer v1 : new Integer[] { 1, null })
1694 +        for (Integer v2 : new Integer[] { 2, null })
1695      {
1696          final CompletableFuture<Integer> f = new CompletableFuture<>();
1697          final CompletableFuture<Integer> g = new CompletableFuture<>();
1698 <        final CFException ex = new CFException();
1699 <        final IncFunction r = new IncFunction();
1698 >        final IncFunction[] rs = new IncFunction[6];
1699 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1700  
1701 <        if (!createIncomplete) (fFirst ? f : g).completeExceptionally(ex);
1702 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1703 <        if (createIncomplete) {
1704 <            checkIncomplete(h);
1705 <            assertEquals(0, r.invocationCount);
1706 <            (fFirst ? f : g).completeExceptionally(ex);
1707 <        }
1701 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1702 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1703 >        checkIncomplete(h0);
1704 >        checkIncomplete(h1);
1705 >        rs[0].assertNotInvoked();
1706 >        rs[1].assertNotInvoked();
1707 >        f.complete(v1);
1708 >        checkCompletedNormally(h0, inc(v1));
1709 >        checkCompletedNormally(h1, inc(v1));
1710 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1711 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1712 >        checkCompletedNormally(h2, inc(v1));
1713 >        checkCompletedNormally(h3, inc(v1));
1714 >        g.complete(v2);
1715  
1716 <        checkCompletedWithWrappedCFException(h, ex);
1717 <        (!fFirst ? f : g).complete(v1);
1716 >        // unspecified behavior - both source completions available
1717 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1718 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1719 >        rs[4].assertValue(h4.join());
1720 >        rs[5].assertValue(h5.join());
1721 >        assertTrue(Objects.equals(inc(v1), h4.join()) ||
1722 >                   Objects.equals(inc(v2), h4.join()));
1723 >        assertTrue(Objects.equals(inc(v1), h5.join()) ||
1724 >                   Objects.equals(inc(v2), h5.join()));
1725  
1726 <        assertEquals(0, r.invocationCount);
1727 <        checkCompletedNormally(!fFirst ? f : g, v1);
1728 <        checkCompletedWithWrappedCFException(fFirst ? f : g, ex);
1729 <        checkCompletedWithWrappedCFException(h, ex);
1726 >        checkCompletedNormally(f, v1);
1727 >        checkCompletedNormally(g, v2);
1728 >        checkCompletedNormally(h0, inc(v1));
1729 >        checkCompletedNormally(h1, inc(v1));
1730 >        checkCompletedNormally(h2, inc(v1));
1731 >        checkCompletedNormally(h3, inc(v1));
1732 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
1733      }}
1734  
1735 <    public void testApplyToEither_exceptionalCompletion2() {
1735 >    /**
1736 >     * applyToEither result completes exceptionally after exceptional
1737 >     * completion of either source
1738 >     */
1739 >    public void testApplyToEither_exceptionalCompletion() {
1740          for (ExecutionMode m : ExecutionMode.values())
1687        for (boolean reverseArgs : new boolean[] { true, false })
1688        for (boolean fFirst : new boolean[] { true, false })
1741          for (Integer v1 : new Integer[] { 1, null })
1742      {
1743          final CompletableFuture<Integer> f = new CompletableFuture<>();
1744          final CompletableFuture<Integer> g = new CompletableFuture<>();
1693        final IncFunction r1 = new IncFunction();
1694        final IncFunction r2 = new IncFunction();
1745          final CFException ex = new CFException();
1746 <        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1747 <        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1698 <        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1699 <        if (fFirst) {
1700 <            f.complete(v1);
1701 <            g.completeExceptionally(ex);
1702 <        } else {
1703 <            g.completeExceptionally(ex);
1704 <            f.complete(v1);
1705 <        }
1706 <        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1746 >        final IncFunction[] rs = new IncFunction[6];
1747 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1748  
1749 <        // unspecified behavior
1749 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1750 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1751 >        checkIncomplete(h0);
1752 >        checkIncomplete(h1);
1753 >        rs[0].assertNotInvoked();
1754 >        rs[1].assertNotInvoked();
1755 >        f.completeExceptionally(ex);
1756 >        checkCompletedWithWrappedCFException(h0, ex);
1757 >        checkCompletedWithWrappedCFException(h1, ex);
1758 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1759 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1760 >        checkCompletedWithWrappedCFException(h2, ex);
1761 >        checkCompletedWithWrappedCFException(h3, ex);
1762 >        g.complete(v1);
1763 >
1764 >        // unspecified behavior - both source completions available
1765 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1766 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1767          try {
1768 <            assertEquals(inc(v1), h1.join());
1769 <            assertEquals(1, r1.invocationCount);
1768 >            assertEquals(inc(v1), h4.join());
1769 >            rs[4].assertInvoked();
1770          } catch (CompletionException ok) {
1771 <            checkCompletedWithWrappedCFException(h1, ex);
1772 <            assertEquals(0, r1.invocationCount);
1771 >            checkCompletedWithWrappedCFException(h4, ex);
1772 >            rs[4].assertNotInvoked();
1773          }
1716
1774          try {
1775 <            assertEquals(inc(v1), h2.join());
1776 <            assertEquals(1, r2.invocationCount);
1775 >            assertEquals(inc(v1), h5.join());
1776 >            rs[5].assertInvoked();
1777          } catch (CompletionException ok) {
1778 <            checkCompletedWithWrappedCFException(h2, ex);
1779 <            assertEquals(0, r2.invocationCount);
1778 >            checkCompletedWithWrappedCFException(h5, ex);
1779 >            rs[5].assertNotInvoked();
1780          }
1781  
1782 <        checkCompletedWithWrappedCFException(g, ex);
1783 <        checkCompletedNormally(f, v1);
1784 <    }}
1785 <
1786 <    /**
1787 <     * applyToEither result completes exceptionally if action does
1788 <     */
1789 <    public void testApplyToEither_actionFailed1() {
1733 <        for (ExecutionMode m : ExecutionMode.values())
1734 <        for (Integer v1 : new Integer[] { 1, null })
1735 <        for (Integer v2 : new Integer[] { 2, null })
1736 <    {
1737 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1738 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1739 <        final FailingFunction r = new FailingFunction();
1740 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1741 <
1742 <        f.complete(v1);
1743 <        checkCompletedWithWrappedCFException(h);
1744 <        g.complete(v2);
1745 <        checkCompletedNormally(f, v1);
1746 <        checkCompletedNormally(g, v2);
1747 <    }}
1748 <
1749 <    public void testApplyToEither_actionFailed2() {
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 FailingFunction r = new FailingFunction();
1757 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1758 <
1759 <        g.complete(v2);
1760 <        checkCompletedWithWrappedCFException(h);
1761 <        f.complete(v1);
1762 <        checkCompletedNormally(f, v1);
1763 <        checkCompletedNormally(g, v2);
1782 >        checkCompletedWithWrappedCFException(f, ex);
1783 >        checkCompletedNormally(g, v1);
1784 >        checkCompletedWithWrappedCFException(h0, ex);
1785 >        checkCompletedWithWrappedCFException(h1, ex);
1786 >        checkCompletedWithWrappedCFException(h2, ex);
1787 >        checkCompletedWithWrappedCFException(h3, ex);
1788 >        checkCompletedWithWrappedCFException(h4, ex);
1789 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1790      }}
1791  
1792      /**
1793       * applyToEither result completes exceptionally if either source cancelled
1794       */
1795 <    public void testApplyToEither_sourceCancelled1() {
1770 <        for (ExecutionMode m : ExecutionMode.values())
1771 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1772 <        for (boolean createIncomplete : new boolean[] { true, false })
1773 <        for (boolean fFirst : new boolean[] { true, false })
1774 <        for (Integer v1 : new Integer[] { 1, null })
1775 <    {
1776 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1777 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1778 <        final IncFunction r = new IncFunction();
1779 <
1780 <        if (!createIncomplete) assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1781 <        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
1782 <        if (createIncomplete) {
1783 <            checkIncomplete(h);
1784 <            assertEquals(0, r.invocationCount);
1785 <            assertTrue((fFirst ? f : g).cancel(mayInterruptIfRunning));
1786 <        }
1787 <
1788 <        checkCompletedWithWrappedCancellationException(h);
1789 <        (!fFirst ? f : g).complete(v1);
1790 <
1791 <        assertEquals(0, r.invocationCount);
1792 <        checkCompletedNormally(!fFirst ? f : g, v1);
1793 <        checkCancelled(fFirst ? f : g);
1794 <        checkCompletedWithWrappedCancellationException(h);
1795 <    }}
1796 <
1797 <    public void testApplyToEither_sourceCancelled2() {
1795 >    public void testApplyToEither_sourceCancelled() {
1796          for (ExecutionMode m : ExecutionMode.values())
1797          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1800        for (boolean reverseArgs : new boolean[] { true, false })
1801        for (boolean fFirst : new boolean[] { true, false })
1798          for (Integer v1 : new Integer[] { 1, null })
1799      {
1800          final CompletableFuture<Integer> f = new CompletableFuture<>();
1801          final CompletableFuture<Integer> g = new CompletableFuture<>();
1802 <        final IncFunction r1 = new IncFunction();
1803 <        final IncFunction r2 = new IncFunction();
1808 <        final CFException ex = new CFException();
1809 <        final CompletableFuture<Integer> j = (reverseArgs ? g : f);
1810 <        final CompletableFuture<Integer> k = (reverseArgs ? f : g);
1802 >        final IncFunction[] rs = new IncFunction[6];
1803 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
1804  
1805 <        final CompletableFuture<Integer> h1 = m.applyToEither(j, k, r1);
1806 <        if (fFirst) {
1807 <            f.complete(v1);
1808 <            assertTrue(g.cancel(mayInterruptIfRunning));
1809 <        } else {
1810 <            assertTrue(g.cancel(mayInterruptIfRunning));
1811 <            f.complete(v1);
1812 <        }
1813 <        final CompletableFuture<Integer> h2 = m.applyToEither(j, k, r2);
1805 >        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1806 >        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1807 >        checkIncomplete(h0);
1808 >        checkIncomplete(h1);
1809 >        rs[0].assertNotInvoked();
1810 >        rs[1].assertNotInvoked();
1811 >        f.cancel(mayInterruptIfRunning);
1812 >        checkCompletedWithWrappedCancellationException(h0);
1813 >        checkCompletedWithWrappedCancellationException(h1);
1814 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1815 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1816 >        checkCompletedWithWrappedCancellationException(h2);
1817 >        checkCompletedWithWrappedCancellationException(h3);
1818 >        g.complete(v1);
1819  
1820 <        // unspecified behavior
1820 >        // unspecified behavior - both source completions available
1821 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1822 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1823          try {
1824 <            assertEquals(inc(v1), h1.join());
1825 <            assertEquals(1, r1.invocationCount);
1824 >            assertEquals(inc(v1), h4.join());
1825 >            rs[4].assertInvoked();
1826          } catch (CompletionException ok) {
1827 <            checkCompletedWithWrappedCancellationException(h1);
1828 <            assertEquals(0, r1.invocationCount);
1827 >            checkCompletedWithWrappedCancellationException(h4);
1828 >            rs[4].assertNotInvoked();
1829          }
1830
1830          try {
1831 <            assertEquals(inc(v1), h2.join());
1832 <            assertEquals(1, r2.invocationCount);
1831 >            assertEquals(inc(v1), h5.join());
1832 >            rs[5].assertInvoked();
1833          } catch (CompletionException ok) {
1834 <            checkCompletedWithWrappedCancellationException(h2);
1835 <            assertEquals(0, r2.invocationCount);
1834 >            checkCompletedWithWrappedCancellationException(h5);
1835 >            rs[5].assertNotInvoked();
1836          }
1837  
1838 <        checkCancelled(g);
1839 <        checkCompletedNormally(f, v1);
1838 >        checkCancelled(f);
1839 >        checkCompletedNormally(g, v1);
1840 >        checkCompletedWithWrappedCancellationException(h0);
1841 >        checkCompletedWithWrappedCancellationException(h1);
1842 >        checkCompletedWithWrappedCancellationException(h2);
1843 >        checkCompletedWithWrappedCancellationException(h3);
1844 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1845      }}
1846  
1847      /**
1848 <     * acceptEither result completes normally after normal completion
1845 <     * of either source
1848 >     * applyToEither result completes exceptionally if action does
1849       */
1850 <    public void testAcceptEither_normalCompletion1() {
1850 >    public void testApplyToEither_actionFailed() {
1851          for (ExecutionMode m : ExecutionMode.values())
1852          for (Integer v1 : new Integer[] { 1, null })
1853          for (Integer v2 : new Integer[] { 2, null })
1854      {
1855          final CompletableFuture<Integer> f = new CompletableFuture<>();
1856          final CompletableFuture<Integer> g = new CompletableFuture<>();
1857 <        final IncAction r = new IncAction();
1858 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1857 >        final FailingFunction[] rs = new FailingFunction[6];
1858 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingFunction(m);
1859  
1860 +        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
1861 +        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
1862          f.complete(v1);
1863 <        checkCompletedNormally(h, null);
1864 <        assertEquals(inc(v1), r.value);
1865 <        g.complete(v2);
1866 <
1867 <        checkCompletedNormally(f, v1);
1868 <        checkCompletedNormally(g, v2);
1869 <        checkCompletedNormally(h, null);
1865 <    }}
1866 <
1867 <    public void testAcceptEither_normalCompletion2() {
1868 <        for (ExecutionMode m : ExecutionMode.values())
1869 <        for (Integer v1 : new Integer[] { 1, null })
1870 <        for (Integer v2 : new Integer[] { 2, null })
1871 <    {
1872 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1873 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1874 <        final IncAction r = new IncAction();
1875 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1863 >        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
1864 >        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
1865 >        checkCompletedWithWrappedCFException(h0);
1866 >        checkCompletedWithWrappedCFException(h1);
1867 >        checkCompletedWithWrappedCFException(h2);
1868 >        checkCompletedWithWrappedCFException(h3);
1869 >        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
1870  
1871          g.complete(v2);
1872 <        checkCompletedNormally(h, null);
1873 <        assertEquals(inc(v2), r.value);
1874 <        f.complete(v1);
1872 >
1873 >        // unspecified behavior - both source completions available
1874 >        final CompletableFuture<Integer> h4 = m.applyToEither(f, g, rs[4]);
1875 >        final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
1876 >
1877 >        checkCompletedWithWrappedCFException(h4);
1878 >        assertTrue(Objects.equals(v1, rs[4].value) ||
1879 >                   Objects.equals(v2, rs[4].value));
1880 >        checkCompletedWithWrappedCFException(h5);
1881 >        assertTrue(Objects.equals(v1, rs[5].value) ||
1882 >                   Objects.equals(v2, rs[5].value));
1883  
1884          checkCompletedNormally(f, v1);
1885          checkCompletedNormally(g, v2);
1884        checkCompletedNormally(h, null);
1886      }}
1887  
1888 <    public void testAcceptEither_normalCompletion3() {
1888 >    /**
1889 >     * acceptEither result completes normally after normal completion
1890 >     * of either source
1891 >     */
1892 >    public void testAcceptEither_normalCompletion() {
1893          for (ExecutionMode m : ExecutionMode.values())
1894          for (Integer v1 : new Integer[] { 1, null })
1895          for (Integer v2 : new Integer[] { 2, null })
1896      {
1897          final CompletableFuture<Integer> f = new CompletableFuture<>();
1898          final CompletableFuture<Integer> g = new CompletableFuture<>();
1899 <        final IncAction r = new IncAction();
1899 >        final IncAction[] rs = new IncAction[6];
1900 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
1901  
1902 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
1903 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
1904 +        checkIncomplete(h0);
1905 +        checkIncomplete(h1);
1906 +        rs[0].assertNotInvoked();
1907 +        rs[1].assertNotInvoked();
1908          f.complete(v1);
1909 +        checkCompletedNormally(h0, null);
1910 +        checkCompletedNormally(h1, null);
1911 +        rs[0].assertValue(inc(v1));
1912 +        rs[1].assertValue(inc(v1));
1913 +        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
1914 +        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
1915 +        checkCompletedNormally(h2, null);
1916 +        checkCompletedNormally(h3, null);
1917 +        rs[2].assertValue(inc(v1));
1918 +        rs[3].assertValue(inc(v1));
1919          g.complete(v2);
1898        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1920  
1921 <        checkCompletedNormally(h, null);
1921 >        // unspecified behavior - both source completions available
1922 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
1923 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
1924 >        checkCompletedNormally(h4, null);
1925 >        checkCompletedNormally(h5, null);
1926 >        assertTrue(Objects.equals(inc(v1), rs[4].value) ||
1927 >                   Objects.equals(inc(v2), rs[4].value));
1928 >        assertTrue(Objects.equals(inc(v1), rs[5].value) ||
1929 >                   Objects.equals(inc(v2), rs[5].value));
1930 >
1931          checkCompletedNormally(f, v1);
1932          checkCompletedNormally(g, v2);
1933 <
1934 <        // unspecified behavior
1935 <        assertTrue(Objects.equals(r.value, inc(v1)) ||
1936 <                   Objects.equals(r.value, inc(v2)));
1933 >        checkCompletedNormally(h0, null);
1934 >        checkCompletedNormally(h1, null);
1935 >        checkCompletedNormally(h2, null);
1936 >        checkCompletedNormally(h3, null);
1937 >        for (int i = 0; i < 4; i++) rs[i].assertValue(inc(v1));
1938      }}
1939  
1940      /**
1941       * acceptEither result completes exceptionally after exceptional
1942       * completion of either source
1943       */
1944 <    public void testAcceptEither_exceptionalCompletion1() {
1944 >    public void testAcceptEither_exceptionalCompletion() {
1945          for (ExecutionMode m : ExecutionMode.values())
1946          for (Integer v1 : new Integer[] { 1, null })
1947      {
1948          final CompletableFuture<Integer> f = new CompletableFuture<>();
1949          final CompletableFuture<Integer> g = new CompletableFuture<>();
1919        final IncAction r = new IncAction();
1920        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1950          final CFException ex = new CFException();
1951 +        final IncAction[] rs = new IncAction[6];
1952 +        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
1953  
1954 +        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
1955 +        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
1956 +        checkIncomplete(h0);
1957 +        checkIncomplete(h1);
1958 +        rs[0].assertNotInvoked();
1959 +        rs[1].assertNotInvoked();
1960          f.completeExceptionally(ex);
1961 <        checkCompletedWithWrappedCFException(h, ex);
1962 <        g.complete(v1);
1963 <
1964 <        assertEquals(0, r.invocationCount);
1965 <        checkCompletedNormally(g, v1);
1966 <        checkCompletedWithWrappedCFException(f, ex);
1930 <        checkCompletedWithWrappedCFException(h, ex);
1931 <    }}
1932 <
1933 <    public void testAcceptEither_exceptionalCompletion2() {
1934 <        for (ExecutionMode m : ExecutionMode.values())
1935 <        for (Integer v1 : new Integer[] { 1, null })
1936 <    {
1937 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1938 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1939 <        final IncAction r = new IncAction();
1940 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1941 <        final CFException ex = new CFException();
1961 >        checkCompletedWithWrappedCFException(h0, ex);
1962 >        checkCompletedWithWrappedCFException(h1, ex);
1963 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
1964 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
1965 >        checkCompletedWithWrappedCFException(h2, ex);
1966 >        checkCompletedWithWrappedCFException(h3, ex);
1967  
1968 <        g.completeExceptionally(ex);
1944 <        checkCompletedWithWrappedCFException(h, ex);
1945 <        f.complete(v1);
1946 <
1947 <        assertEquals(0, r.invocationCount);
1948 <        checkCompletedNormally(f, v1);
1949 <        checkCompletedWithWrappedCFException(g, ex);
1950 <        checkCompletedWithWrappedCFException(h, ex);
1951 <    }}
1952 <
1953 <    public void testAcceptEither_exceptionalCompletion3() {
1954 <        for (ExecutionMode m : ExecutionMode.values())
1955 <        for (Integer v1 : new Integer[] { 1, null })
1956 <    {
1957 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
1958 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
1959 <        final IncAction r = new IncAction();
1960 <        final CFException ex = new CFException();
1961 <
1962 <        g.completeExceptionally(ex);
1963 <        f.complete(v1);
1964 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1968 >        g.complete(v1);
1969  
1970 <        // unspecified behavior
1971 <        Integer v;
1970 >        // unspecified behavior - both source completions available
1971 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
1972 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
1973          try {
1974 <            assertNull(h.join());
1975 <            assertEquals(1, r.invocationCount);
1971 <            assertEquals(inc(v1), r.value);
1974 >            assertNull(h4.join());
1975 >            rs[4].assertValue(inc(v1));
1976          } catch (CompletionException ok) {
1977 <            checkCompletedWithWrappedCFException(h, ex);
1978 <            assertEquals(0, r.invocationCount);
1977 >            checkCompletedWithWrappedCFException(h4, ex);
1978 >            rs[4].assertNotInvoked();
1979          }
1976
1977        checkCompletedWithWrappedCFException(g, ex);
1978        checkCompletedNormally(f, v1);
1979    }}
1980
1981    public void testAcceptEither_exceptionalCompletion4() {
1982        for (ExecutionMode m : ExecutionMode.values())
1983        for (Integer v1 : new Integer[] { 1, null })
1984    {
1985        final CompletableFuture<Integer> f = new CompletableFuture<>();
1986        final CompletableFuture<Integer> g = new CompletableFuture<>();
1987        final IncAction r = new IncAction();
1988        final CFException ex = new CFException();
1989
1990        f.completeExceptionally(ex);
1991        g.complete(v1);
1992        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
1993
1994        // unspecified behavior
1995        Integer v;
1980          try {
1981 <            assertNull(h.join());
1982 <            assertEquals(1, r.invocationCount);
1999 <            assertEquals(inc(v1), r.value);
1981 >            assertNull(h5.join());
1982 >            rs[5].assertValue(inc(v1));
1983          } catch (CompletionException ok) {
1984 <            checkCompletedWithWrappedCFException(h, ex);
1985 <            assertEquals(0, r.invocationCount);
1984 >            checkCompletedWithWrappedCFException(h5, ex);
1985 >            rs[5].assertNotInvoked();
1986          }
1987  
1988          checkCompletedWithWrappedCFException(f, ex);
1989          checkCompletedNormally(g, v1);
1990 <    }}
1991 <
1992 <    /**
1993 <     * acceptEither result completes exceptionally if action does
1994 <     */
1995 <    public void testAcceptEither_actionFailed1() {
2013 <        for (ExecutionMode m : ExecutionMode.values())
2014 <        for (Integer v1 : new Integer[] { 1, null })
2015 <        for (Integer v2 : new Integer[] { 2, null })
2016 <    {
2017 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2018 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2019 <        final FailingConsumer r = new FailingConsumer();
2020 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2021 <
2022 <        f.complete(v1);
2023 <        checkCompletedWithWrappedCFException(h);
2024 <        g.complete(v2);
2025 <        checkCompletedNormally(f, v1);
2026 <        checkCompletedNormally(g, v2);
2027 <    }}
2028 <
2029 <    public void testAcceptEither_actionFailed2() {
2030 <        for (ExecutionMode m : ExecutionMode.values())
2031 <        for (Integer v1 : new Integer[] { 1, null })
2032 <        for (Integer v2 : new Integer[] { 2, null })
2033 <    {
2034 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2035 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2036 <        final FailingConsumer r = new FailingConsumer();
2037 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2038 <
2039 <        g.complete(v2);
2040 <        checkCompletedWithWrappedCFException(h);
2041 <        f.complete(v1);
2042 <        checkCompletedNormally(f, v1);
2043 <        checkCompletedNormally(g, v2);
1990 >        checkCompletedWithWrappedCFException(h0, ex);
1991 >        checkCompletedWithWrappedCFException(h1, ex);
1992 >        checkCompletedWithWrappedCFException(h2, ex);
1993 >        checkCompletedWithWrappedCFException(h3, ex);
1994 >        checkCompletedWithWrappedCFException(h4, ex);
1995 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
1996      }}
1997  
1998      /**
1999       * acceptEither result completes exceptionally if either source cancelled
2000       */
2001 <    public void testAcceptEither_sourceCancelled1() {
2001 >    public void testAcceptEither_sourceCancelled() {
2002          for (ExecutionMode m : ExecutionMode.values())
2003          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2004          for (Integer v1 : new Integer[] { 1, null })
2005      {
2006          final CompletableFuture<Integer> f = new CompletableFuture<>();
2007          final CompletableFuture<Integer> g = new CompletableFuture<>();
2008 <        final IncAction r = new IncAction();
2009 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2008 >        final IncAction[] rs = new IncAction[6];
2009 >        for (int i = 0; i < rs.length; i++) rs[i] = new IncAction(m);
2010 >
2011 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2012 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2013 >        checkIncomplete(h0);
2014 >        checkIncomplete(h1);
2015 >        rs[0].assertNotInvoked();
2016 >        rs[1].assertNotInvoked();
2017 >        f.cancel(mayInterruptIfRunning);
2018 >        checkCompletedWithWrappedCancellationException(h0);
2019 >        checkCompletedWithWrappedCancellationException(h1);
2020 >        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2021 >        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2022 >        checkCompletedWithWrappedCancellationException(h2);
2023 >        checkCompletedWithWrappedCancellationException(h3);
2024  
2059        assertTrue(f.cancel(mayInterruptIfRunning));
2060        checkCompletedWithWrappedCancellationException(h);
2025          g.complete(v1);
2026  
2027 +        // unspecified behavior - both source completions available
2028 +        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2029 +        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2030 +        try {
2031 +            assertNull(h4.join());
2032 +            rs[4].assertValue(inc(v1));
2033 +        } catch (CompletionException ok) {
2034 +            checkCompletedWithWrappedCancellationException(h4);
2035 +            rs[4].assertNotInvoked();
2036 +        }
2037 +        try {
2038 +            assertNull(h5.join());
2039 +            rs[5].assertValue(inc(v1));
2040 +        } catch (CompletionException ok) {
2041 +            checkCompletedWithWrappedCancellationException(h5);
2042 +            rs[5].assertNotInvoked();
2043 +        }
2044 +
2045          checkCancelled(f);
2064        assertEquals(0, r.invocationCount);
2046          checkCompletedNormally(g, v1);
2047 <        checkCompletedWithWrappedCancellationException(h);
2047 >        checkCompletedWithWrappedCancellationException(h0);
2048 >        checkCompletedWithWrappedCancellationException(h1);
2049 >        checkCompletedWithWrappedCancellationException(h2);
2050 >        checkCompletedWithWrappedCancellationException(h3);
2051 >        for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
2052      }}
2053  
2054 <    public void testAcceptEither_sourceCancelled2() {
2054 >    /**
2055 >     * acceptEither result completes exceptionally if action does
2056 >     */
2057 >    public void testAcceptEither_actionFailed() {
2058          for (ExecutionMode m : ExecutionMode.values())
2071        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2059          for (Integer v1 : new Integer[] { 1, null })
2060 +        for (Integer v2 : new Integer[] { 2, null })
2061      {
2062          final CompletableFuture<Integer> f = new CompletableFuture<>();
2063          final CompletableFuture<Integer> g = new CompletableFuture<>();
2064 <        final IncAction r = new IncAction();
2065 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2064 >        final FailingConsumer[] rs = new FailingConsumer[6];
2065 >        for (int i = 0; i < rs.length; i++) rs[i] = new FailingConsumer(m);
2066  
2067 <        assertTrue(g.cancel(mayInterruptIfRunning));
2068 <        checkCompletedWithWrappedCancellationException(h);
2067 >        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
2068 >        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
2069          f.complete(v1);
2070 +        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
2071 +        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
2072 +        checkCompletedWithWrappedCFException(h0);
2073 +        checkCompletedWithWrappedCFException(h1);
2074 +        checkCompletedWithWrappedCFException(h2);
2075 +        checkCompletedWithWrappedCFException(h3);
2076 +        for (int i = 0; i < 4; i++) rs[i].assertValue(v1);
2077  
2078 <        checkCancelled(g);
2084 <        assertEquals(0, r.invocationCount);
2085 <        checkCompletedNormally(f, v1);
2086 <        checkCompletedWithWrappedCancellationException(h);
2087 <    }}
2088 <
2089 <    public void testAcceptEither_sourceCancelled3() {
2090 <        for (ExecutionMode m : ExecutionMode.values())
2091 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2092 <        for (Integer v1 : new Integer[] { 1, null })
2093 <    {
2094 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2095 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2096 <        final IncAction r = new IncAction();
2097 <
2098 <        assertTrue(g.cancel(mayInterruptIfRunning));
2099 <        f.complete(v1);
2100 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2078 >        g.complete(v2);
2079  
2080 <        // unspecified behavior
2081 <        Integer v;
2082 <        try {
2083 <            assertNull(h.join());
2084 <            assertEquals(1, r.invocationCount);
2085 <            assertEquals(inc(v1), r.value);
2086 <        } catch (CompletionException ok) {
2087 <            checkCompletedWithWrappedCancellationException(h);
2088 <            assertEquals(0, r.invocationCount);
2089 <        }
2080 >        // unspecified behavior - both source completions available
2081 >        final CompletableFuture<Void> h4 = m.acceptEither(f, g, rs[4]);
2082 >        final CompletableFuture<Void> h5 = m.acceptEither(g, f, rs[5]);
2083 >
2084 >        checkCompletedWithWrappedCFException(h4);
2085 >        assertTrue(Objects.equals(v1, rs[4].value) ||
2086 >                   Objects.equals(v2, rs[4].value));
2087 >        checkCompletedWithWrappedCFException(h5);
2088 >        assertTrue(Objects.equals(v1, rs[5].value) ||
2089 >                   Objects.equals(v2, rs[5].value));
2090  
2113        checkCancelled(g);
2091          checkCompletedNormally(f, v1);
2092 <    }}
2116 <
2117 <    public void testAcceptEither_sourceCancelled4() {
2118 <        for (ExecutionMode m : ExecutionMode.values())
2119 <        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2120 <        for (Integer v1 : new Integer[] { 1, null })
2121 <    {
2122 <        final CompletableFuture<Integer> f = new CompletableFuture<>();
2123 <        final CompletableFuture<Integer> g = new CompletableFuture<>();
2124 <        final IncAction r = new IncAction();
2125 <
2126 <        assertTrue(f.cancel(mayInterruptIfRunning));
2127 <        g.complete(v1);
2128 <        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2129 <
2130 <        // unspecified behavior
2131 <        Integer v;
2132 <        try {
2133 <            assertNull(h.join());
2134 <            assertEquals(1, r.invocationCount);
2135 <            assertEquals(inc(v1), r.value);
2136 <        } catch (CompletionException ok) {
2137 <            checkCompletedWithWrappedCancellationException(h);
2138 <            assertEquals(0, r.invocationCount);
2139 <        }
2140 <
2141 <        checkCancelled(f);
2142 <        checkCompletedNormally(g, v1);
2092 >        checkCompletedNormally(g, v2);
2093      }}
2094  
2095      /**
# Line 2153 | Line 2103 | public class CompletableFutureTest exten
2103      {
2104          final CompletableFuture<Integer> f = new CompletableFuture<>();
2105          final CompletableFuture<Integer> g = new CompletableFuture<>();
2106 <        final Noop r = new Noop();
2106 >        final Noop r = new Noop(m);
2107          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2108  
2109          f.complete(v1);
2110          checkCompletedNormally(h, null);
2111 <        assertEquals(1, r.invocationCount);
2111 >        r.assertInvoked();
2112          g.complete(v2);
2113  
2114          checkCompletedNormally(f, v1);
2115          checkCompletedNormally(g, v2);
2116          checkCompletedNormally(h, null);
2117 <        assertEquals(1, r.invocationCount);
2117 >        r.assertInvoked();
2118      }}
2119  
2120      public void testRunAfterEither_normalCompletion2() {
# Line 2174 | Line 2124 | public class CompletableFutureTest exten
2124      {
2125          final CompletableFuture<Integer> f = new CompletableFuture<>();
2126          final CompletableFuture<Integer> g = new CompletableFuture<>();
2127 <        final Noop r = new Noop();
2127 >        final Noop r = new Noop(m);
2128          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2129  
2130          g.complete(v2);
2131          checkCompletedNormally(h, null);
2132 <        assertEquals(1, r.invocationCount);
2132 >        r.assertInvoked();
2133          f.complete(v1);
2134  
2135          checkCompletedNormally(f, v1);
2136          checkCompletedNormally(g, v2);
2137          checkCompletedNormally(h, null);
2138 <        assertEquals(1, r.invocationCount);
2138 >        r.assertInvoked();
2139          }}
2140  
2141      public void testRunAfterEither_normalCompletion3() {
# Line 2195 | Line 2145 | public class CompletableFutureTest exten
2145      {
2146          final CompletableFuture<Integer> f = new CompletableFuture<>();
2147          final CompletableFuture<Integer> g = new CompletableFuture<>();
2148 <        final Noop r = new Noop();
2148 >        final Noop r = new Noop(m);
2149  
2150          f.complete(v1);
2151          g.complete(v2);
# Line 2204 | Line 2154 | public class CompletableFutureTest exten
2154          checkCompletedNormally(h, null);
2155          checkCompletedNormally(f, v1);
2156          checkCompletedNormally(g, v2);
2157 <        assertEquals(1, r.invocationCount);
2157 >        r.assertInvoked();
2158      }}
2159  
2160      /**
# Line 2217 | Line 2167 | public class CompletableFutureTest exten
2167      {
2168          final CompletableFuture<Integer> f = new CompletableFuture<>();
2169          final CompletableFuture<Integer> g = new CompletableFuture<>();
2170 <        final Noop r = new Noop();
2170 >        final Noop r = new Noop(m);
2171          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2172          final CFException ex = new CFException();
2173  
# Line 2225 | Line 2175 | public class CompletableFutureTest exten
2175          checkCompletedWithWrappedCFException(h, ex);
2176          g.complete(v1);
2177  
2178 <        assertEquals(0, r.invocationCount);
2178 >        r.assertNotInvoked();
2179          checkCompletedNormally(g, v1);
2180          checkCompletedWithWrappedCFException(f, ex);
2181          checkCompletedWithWrappedCFException(h, ex);
# Line 2237 | Line 2187 | public class CompletableFutureTest exten
2187      {
2188          final CompletableFuture<Integer> f = new CompletableFuture<>();
2189          final CompletableFuture<Integer> g = new CompletableFuture<>();
2190 <        final Noop r = new Noop();
2190 >        final Noop r = new Noop(m);
2191          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2192          final CFException ex = new CFException();
2193  
# Line 2245 | Line 2195 | public class CompletableFutureTest exten
2195          checkCompletedWithWrappedCFException(h, ex);
2196          f.complete(v1);
2197  
2198 <        assertEquals(0, r.invocationCount);
2198 >        r.assertNotInvoked();
2199          checkCompletedNormally(f, v1);
2200          checkCompletedWithWrappedCFException(g, ex);
2201          checkCompletedWithWrappedCFException(h, ex);
# Line 2257 | Line 2207 | public class CompletableFutureTest exten
2207      {
2208          final CompletableFuture<Integer> f = new CompletableFuture<>();
2209          final CompletableFuture<Integer> g = new CompletableFuture<>();
2210 <        final Noop r = new Noop();
2210 >        final Noop r = new Noop(m);
2211          final CFException ex = new CFException();
2212  
2213          g.completeExceptionally(ex);
# Line 2268 | Line 2218 | public class CompletableFutureTest exten
2218          Integer v;
2219          try {
2220              assertNull(h.join());
2221 <            assertEquals(1, r.invocationCount);
2221 >            r.assertInvoked();
2222          } catch (CompletionException ok) {
2223              checkCompletedWithWrappedCFException(h, ex);
2224 <            assertEquals(0, r.invocationCount);
2224 >            r.assertNotInvoked();
2225          }
2226  
2227          checkCompletedWithWrappedCFException(g, ex);
# Line 2284 | 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 CFException ex = new CFException();
2239  
2240          f.completeExceptionally(ex);
# Line 2295 | Line 2245 | public class CompletableFutureTest exten
2245          Integer v;
2246          try {
2247              assertNull(h.join());
2248 <            assertEquals(1, r.invocationCount);
2248 >            r.assertInvoked();
2249          } catch (CompletionException ok) {
2250              checkCompletedWithWrappedCFException(h, ex);
2251 <            assertEquals(0, r.invocationCount);
2251 >            r.assertNotInvoked();
2252          }
2253  
2254          checkCompletedWithWrappedCFException(f, ex);
# Line 2315 | Line 2265 | public class CompletableFutureTest exten
2265      {
2266          final CompletableFuture<Integer> f = new CompletableFuture<>();
2267          final CompletableFuture<Integer> g = new CompletableFuture<>();
2268 <        final FailingRunnable r = new FailingRunnable();
2268 >        final FailingRunnable r = new FailingRunnable(m);
2269          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2270  
2271          f.complete(v1);
# Line 2332 | Line 2282 | public class CompletableFutureTest exten
2282      {
2283          final CompletableFuture<Integer> f = new CompletableFuture<>();
2284          final CompletableFuture<Integer> g = new CompletableFuture<>();
2285 <        final FailingRunnable r = new FailingRunnable();
2285 >        final FailingRunnable r = new FailingRunnable(m);
2286          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2287  
2288          g.complete(v2);
# Line 2352 | Line 2302 | public class CompletableFutureTest exten
2302      {
2303          final CompletableFuture<Integer> f = new CompletableFuture<>();
2304          final CompletableFuture<Integer> g = new CompletableFuture<>();
2305 <        final Noop r = new Noop();
2305 >        final Noop r = new Noop(m);
2306          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2307  
2308          assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2360 | Line 2310 | public class CompletableFutureTest exten
2310          g.complete(v1);
2311  
2312          checkCancelled(f);
2313 <        assertEquals(0, r.invocationCount);
2313 >        r.assertNotInvoked();
2314          checkCompletedNormally(g, v1);
2315          checkCompletedWithWrappedCancellationException(h);
2316      }}
# Line 2372 | Line 2322 | public class CompletableFutureTest exten
2322      {
2323          final CompletableFuture<Integer> f = new CompletableFuture<>();
2324          final CompletableFuture<Integer> g = new CompletableFuture<>();
2325 <        final Noop r = new Noop();
2325 >        final Noop r = new Noop(m);
2326          final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2327  
2328          assertTrue(g.cancel(mayInterruptIfRunning));
# Line 2380 | Line 2330 | public class CompletableFutureTest exten
2330          f.complete(v1);
2331  
2332          checkCancelled(g);
2333 <        assertEquals(0, r.invocationCount);
2333 >        r.assertNotInvoked();
2334          checkCompletedNormally(f, v1);
2335          checkCompletedWithWrappedCancellationException(h);
2336      }}
# Line 2392 | Line 2342 | public class CompletableFutureTest exten
2342      {
2343          final CompletableFuture<Integer> f = new CompletableFuture<>();
2344          final CompletableFuture<Integer> g = new CompletableFuture<>();
2345 <        final Noop r = new Noop();
2345 >        final Noop r = new Noop(m);
2346  
2347          assertTrue(g.cancel(mayInterruptIfRunning));
2348          f.complete(v1);
# Line 2402 | Line 2352 | public class CompletableFutureTest exten
2352          Integer v;
2353          try {
2354              assertNull(h.join());
2355 <            assertEquals(1, r.invocationCount);
2355 >            r.assertInvoked();
2356          } catch (CompletionException ok) {
2357              checkCompletedWithWrappedCancellationException(h);
2358 <            assertEquals(0, r.invocationCount);
2358 >            r.assertNotInvoked();
2359          }
2360  
2361          checkCancelled(g);
# Line 2419 | Line 2369 | public class CompletableFutureTest exten
2369      {
2370          final CompletableFuture<Integer> f = new CompletableFuture<>();
2371          final CompletableFuture<Integer> g = new CompletableFuture<>();
2372 <        final Noop r = new Noop();
2372 >        final Noop r = new Noop(m);
2373  
2374          assertTrue(f.cancel(mayInterruptIfRunning));
2375          g.complete(v1);
# Line 2429 | Line 2379 | public class CompletableFutureTest exten
2379          Integer v;
2380          try {
2381              assertNull(h.join());
2382 <            assertEquals(1, r.invocationCount);
2382 >            r.assertInvoked();
2383          } catch (CompletionException ok) {
2384              checkCompletedWithWrappedCancellationException(h);
2385 <            assertEquals(0, r.invocationCount);
2385 >            r.assertNotInvoked();
2386          }
2387  
2388          checkCancelled(f);
# Line 2448 | Line 2398 | public class CompletableFutureTest exten
2398          for (Integer v1 : new Integer[] { 1, null })
2399      {
2400          final CompletableFuture<Integer> f = new CompletableFuture<>();
2401 <        final CompletableFutureInc r = new CompletableFutureInc();
2401 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2402          if (!createIncomplete) f.complete(v1);
2403 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2403 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2404          if (createIncomplete) f.complete(v1);
2405  
2406          checkCompletedNormally(g, inc(v1));
2407          checkCompletedNormally(f, v1);
2408 <        assertEquals(1, r.invocationCount);
2408 >        r.assertInvoked();
2409      }}
2410  
2411      /**
# Line 2467 | Line 2417 | public class CompletableFutureTest exten
2417          for (boolean createIncomplete : new boolean[] { true, false })
2418      {
2419          final CFException ex = new CFException();
2420 <        final CompletableFutureInc r = new CompletableFutureInc();
2420 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2421          final CompletableFuture<Integer> f = new CompletableFuture<>();
2422          if (!createIncomplete) f.completeExceptionally(ex);
2423 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2423 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2424          if (createIncomplete) f.completeExceptionally(ex);
2425  
2426          checkCompletedWithWrappedCFException(g, ex);
2427          checkCompletedWithWrappedCFException(f, ex);
2428 <        assertEquals(0, r.invocationCount);
2428 >        r.assertNotInvoked();
2429      }}
2430  
2431      /**
# Line 2488 | Line 2438 | public class CompletableFutureTest exten
2438      {
2439          final CompletableFuture<Integer> f = new CompletableFuture<>();
2440          final FailingCompletableFutureFunction r
2441 <            = new FailingCompletableFutureFunction();
2441 >            = new FailingCompletableFutureFunction(m);
2442          if (!createIncomplete) f.complete(v1);
2443 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2443 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2444          if (createIncomplete) f.complete(v1);
2445  
2446          checkCompletedWithWrappedCFException(g);
# Line 2506 | Line 2456 | public class CompletableFutureTest exten
2456          for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2457      {
2458          final CompletableFuture<Integer> f = new CompletableFuture<>();
2459 <        final CompletableFutureInc r = new CompletableFutureInc();
2459 >        final CompletableFutureInc r = new CompletableFutureInc(m);
2460          if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2461 <        final CompletableFuture<Integer> g = f.thenCompose(r);
2461 >        final CompletableFuture<Integer> g = m.thenCompose(f, r);
2462          if (createIncomplete) {
2463              checkIncomplete(g);
2464              assertTrue(f.cancel(mayInterruptIfRunning));
# Line 2535 | Line 2485 | public class CompletableFutureTest exten
2485       */
2486      public void testAllOf_normal() throws Exception {
2487          for (int k = 1; k < 20; ++k) {
2488 <            CompletableFuture<Integer>[] fs = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2488 >            CompletableFuture<Integer>[] fs
2489 >                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2490              for (int i = 0; i < k; ++i)
2491                  fs[i] = new CompletableFuture<>();
2492              CompletableFuture<Void> f = CompletableFuture.allOf(fs);
# Line 2549 | Line 2500 | public class CompletableFutureTest exten
2500          }
2501      }
2502  
2503 +    public void testAllOf_backwards() throws Exception {
2504 +        for (int k = 1; k < 20; ++k) {
2505 +            CompletableFuture<Integer>[] fs
2506 +                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
2507 +            for (int i = 0; i < k; ++i)
2508 +                fs[i] = new CompletableFuture<>();
2509 +            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
2510 +            for (int i = k - 1; i >= 0; i--) {
2511 +                checkIncomplete(f);
2512 +                checkIncomplete(CompletableFuture.allOf(fs));
2513 +                fs[i].complete(one);
2514 +            }
2515 +            checkCompletedNormally(f, null);
2516 +            checkCompletedNormally(CompletableFuture.allOf(fs), null);
2517 +        }
2518 +    }
2519 +
2520      /**
2521       * anyOf(no component futures) returns an incomplete future
2522       */
# Line 2607 | Line 2575 | public class CompletableFutureTest exten
2575          Runnable[] throwingActions = {
2576              () -> CompletableFuture.supplyAsync(null),
2577              () -> CompletableFuture.supplyAsync(null, exec),
2578 <            () -> CompletableFuture.supplyAsync(supplyOne, null),
2578 >            () -> CompletableFuture.supplyAsync(new IntegerSupplier(ExecutionMode.DEFAULT, 42), null),
2579  
2580              () -> CompletableFuture.runAsync(null),
2581              () -> CompletableFuture.runAsync(null, exec),
# Line 2680 | Line 2648 | public class CompletableFutureTest exten
2648  
2649              () -> f.thenCompose(null),
2650              () -> f.thenComposeAsync(null),
2651 <            () -> f.thenComposeAsync(new CompletableFutureInc(), null),
2651 >            () -> f.thenComposeAsync(new CompletableFutureInc(ExecutionMode.EXECUTOR), null),
2652              () -> f.thenComposeAsync(null, exec),
2653  
2654              () -> f.exceptionally(null),

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines