--- jsr166/src/test/tck/CompletableFutureTest.java	2014/06/01 23:12:45	1.36
+++ jsr166/src/test/tck/CompletableFutureTest.java	2014/06/02 02:19:23	1.42
@@ -318,12 +318,18 @@ public class CompletableFutureTest exten
 
     // Choose non-commutative actions for better coverage
 
-    // A non-commutative function that handles null values as well
-    public static int subtract(Integer x, Integer y) {
-        return ((x == null) ? 42 : x.intValue())
+    // A non-commutative function that handles and produces null values as well.
+    static Integer subtract(Integer x, Integer y) {
+        return (x == null && y == null) ? null :
+            ((x == null) ? 42 : x.intValue())
             - ((y == null) ? 99 : y.intValue());
     }
 
+    // A function that handles and produces null values as well.
+    static Integer inc(Integer x) {
+        return (x == null) ? null : x + 1;
+    }
+
     static final Supplier<Integer> supplyOne =
         () -> Integer.valueOf(1);
     static final Function<Integer, Integer> inc =
@@ -331,12 +337,26 @@ public class CompletableFutureTest exten
     static final BiFunction<Integer, Integer, Integer> subtract =
         (Integer x, Integer y) -> subtract(x, y);
     static final class IncAction implements Consumer<Integer> {
-        int value;
-        public void accept(Integer x) { value = x.intValue() + 1; }
+        int invocationCount = 0;
+        Integer value;
+        public boolean ran() { return invocationCount == 1; }
+        public void accept(Integer x) {
+            invocationCount++;
+            value = inc(x);
+        }
+    }
+    static final class IncFunction implements Function<Integer,Integer> {
+        int invocationCount = 0;
+        Integer value;
+        public boolean ran() { return invocationCount == 1; }
+        public Integer apply(Integer x) {
+            invocationCount++;
+            return value = inc(x);
+        }
     }
     static final class SubtractAction implements BiConsumer<Integer, Integer> {
-        volatile int invocationCount = 0;
-        int value;
+        int invocationCount = 0;
+        Integer value;
         // Check this action was invoked exactly once when result is computed.
         public boolean ran() { return invocationCount == 1; }
         public void accept(Integer x, Integer y) {
@@ -345,18 +365,22 @@ public class CompletableFutureTest exten
         }
     }
     static final class SubtractFunction implements BiFunction<Integer, Integer, Integer> {
-        volatile int invocationCount = 0;
-        int value;
+        int invocationCount = 0;
+        Integer value;
         // Check this action was invoked exactly once when result is computed.
         public boolean ran() { return invocationCount == 1; }
         public Integer apply(Integer x, Integer y) {
             invocationCount++;
-            return subtract(x, y);
+            return value = subtract(x, y);
         }
     }
     static final class Noop implements Runnable {
+        int invocationCount = 0;
         boolean ran;
-        public void run() { ran = true; }
+        public void run() {
+            invocationCount++;
+            ran = true;
+        }
     }
 
     static final class FailingSupplier implements Supplier<Integer> {
@@ -447,6 +471,34 @@ public class CompletableFutureTest exten
                  BiFunction<? super T,? super U,? extends V> a) {
                 return f.thenCombine(g, a);
             }
+            public <T,U> CompletableFuture<U> applyToEither
+                (CompletableFuture<T> f,
+                 CompletionStage<? extends T> g,
+                 Function<? super T,U> a) {
+                return f.applyToEither(g, a);
+            }
+            public <T> CompletableFuture<Void> acceptEither
+                (CompletableFuture<T> f,
+                 CompletionStage<? extends T> g,
+                 Consumer<? super T> a) {
+                return f.acceptEither(g, a);
+            }
+            public <T> CompletableFuture<Void> runAfterEither
+                (CompletableFuture<T> f,
+                 CompletionStage<?> g,
+                 java.lang.Runnable a) {
+                return f.runAfterEither(g, a);
+            }
+            public <T,U> CompletableFuture<U> thenCompose
+                (CompletableFuture<T> f,
+                 Function<? super T,? extends CompletionStage<U>> a) {
+                return f.thenCompose(a);
+            }
+            public <T> CompletableFuture<T> whenComplete
+                (CompletableFuture<T> f,
+                 BiConsumer<? super T,? super Throwable> a) {
+                return f.whenComplete(a);
+            }
         },
 
 //             /** Experimental way to do more testing */
@@ -480,6 +532,34 @@ public class CompletableFutureTest exten
                  BiFunction<? super T,? super U,? extends V> a) {
                 return f.thenCombineAsync(g, a);
             }
+            public <T,U> CompletableFuture<U> applyToEither
+                (CompletableFuture<T> f,
+                 CompletionStage<? extends T> g,
+                 Function<? super T,U> a) {
+                return f.applyToEitherAsync(g, a);
+            }
+            public <T> CompletableFuture<Void> acceptEither
+                (CompletableFuture<T> f,
+                 CompletionStage<? extends T> g,
+                 Consumer<? super T> a) {
+                return f.acceptEitherAsync(g, a);
+            }
+            public <T> CompletableFuture<Void> runAfterEither
+                (CompletableFuture<T> f,
+                 CompletionStage<?> g,
+                 java.lang.Runnable a) {
+                return f.runAfterEitherAsync(g, a);
+            }
+            public <T,U> CompletableFuture<U> thenCompose
+                (CompletableFuture<T> f,
+                 Function<? super T,? extends CompletionStage<U>> a) {
+                return f.thenComposeAsync(a);
+            }
+            public <T> CompletableFuture<T> whenComplete
+                (CompletableFuture<T> f,
+                 BiConsumer<? super T,? super Throwable> a) {
+                return f.whenCompleteAsync(a);
+            }
         },
 
 //         REVERSE_DEFAULT_ASYNC {
@@ -512,6 +592,34 @@ public class CompletableFutureTest exten
                  BiFunction<? super T,? super U,? extends V> a) {
                 return f.thenCombineAsync(g, a, new ThreadExecutor());
             }
+            public <T,U> CompletableFuture<U> applyToEither
+                (CompletableFuture<T> f,
+                 CompletionStage<? extends T> g,
+                 Function<? super T,U> a) {
+                return f.applyToEitherAsync(g, a, new ThreadExecutor());
+            }
+            public <T> CompletableFuture<Void> acceptEither
+                (CompletableFuture<T> f,
+                 CompletionStage<? extends T> g,
+                 Consumer<? super T> a) {
+                return f.acceptEitherAsync(g, a, new ThreadExecutor());
+            }
+            public <T> CompletableFuture<Void> runAfterEither
+                (CompletableFuture<T> f,
+                 CompletionStage<?> g,
+                 java.lang.Runnable a) {
+                return f.runAfterEitherAsync(g, a, new ThreadExecutor());
+            }
+            public <T,U> CompletableFuture<U> thenCompose
+                (CompletableFuture<T> f,
+                 Function<? super T,? extends CompletionStage<U>> a) {
+                return f.thenComposeAsync(a, new ThreadExecutor());
+            }
+            public <T> CompletableFuture<T> whenComplete
+                (CompletableFuture<T> f,
+                 BiConsumer<? super T,? super Throwable> a) {
+                return f.whenCompleteAsync(a, new ThreadExecutor());
+            }
         };
 
         public abstract <T,U> CompletableFuture<Void> runAfterBoth
@@ -524,6 +632,26 @@ public class CompletableFutureTest exten
             (CompletableFuture<T> f,
              CompletionStage<? extends U> g,
              BiFunction<? super T,? super U,? extends V> a);
+        public abstract <T,U> CompletableFuture<U> applyToEither
+            (CompletableFuture<T> f,
+             CompletionStage<? extends T> g,
+             Function<? super T,U> a);
+        public abstract <T> CompletableFuture<Void> acceptEither
+            (CompletableFuture<T> f,
+             CompletionStage<? extends T> g,
+             Consumer<? super T> a);
+        public abstract <T> CompletableFuture<Void> runAfterEither
+            (CompletableFuture<T> f,
+             CompletionStage<?> g,
+             java.lang.Runnable a);
+        public abstract <T,U> CompletableFuture<U> thenCompose
+            (CompletableFuture<T> f,
+             Function<? super T,? extends CompletionStage<U>> a);
+        public abstract <T> CompletableFuture<T> whenComplete
+            (CompletableFuture<T> f,
+             BiConsumer<? super T,? super Throwable> a);
+
+
     }
 
     /**
@@ -776,7 +904,7 @@ public class CompletableFutureTest exten
         CompletableFuture<Void> g = f.thenAccept(r);
         f.complete(one);
         checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
+        assertEquals(r.value, (Integer) 2);
     }
 
     /**
@@ -830,12 +958,13 @@ public class CompletableFutureTest exten
 
         f.complete(v1);
         checkIncomplete(h);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         g.complete(v2);
 
         checkCompletedNormally(h, subtract(v1, v2));
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
+        assertEquals(r.invocationCount, 1);
         }
     }
 
@@ -851,12 +980,13 @@ public class CompletableFutureTest exten
 
         g.complete(v2);
         checkIncomplete(h);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         f.complete(v1);
 
         checkCompletedNormally(h, subtract(v1, v2));
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
+        assertEquals(r.invocationCount, 1);
         }
     }
 
@@ -876,6 +1006,7 @@ public class CompletableFutureTest exten
         checkCompletedNormally(h, subtract(v1, v2));
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
+        assertEquals(r.invocationCount, 1);
         }
     }
 
@@ -895,6 +1026,7 @@ public class CompletableFutureTest exten
         checkCompletedNormally(h, subtract(v1, v2));
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
+        assertEquals(r.invocationCount, 1);
         }
     }
 
@@ -918,7 +1050,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(f, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -930,7 +1062,7 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> f = new CompletableFuture<>();
         final CompletableFuture<Integer> g = new CompletableFuture<>();
         final SubtractFunction r = new SubtractFunction();
-        final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
+        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
         final CFException ex = new CFException();
 
         g.completeExceptionally(ex);
@@ -939,7 +1071,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(g, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -959,7 +1091,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(g, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -975,11 +1107,11 @@ public class CompletableFutureTest exten
 
         f.completeExceptionally(ex);
         g.complete(v1);
-        final CompletableFuture<Integer> h = m.thenCombine(f, g, subtract);
+        final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(f, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1046,7 +1178,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(f);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1067,7 +1199,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(g);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1087,7 +1219,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(g);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1107,7 +1239,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(f);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1128,7 +1260,7 @@ public class CompletableFutureTest exten
 
         f.complete(v1);
         checkIncomplete(h);
-        assertEquals(r.value, 0);
+        assertFalse(r.ran());
         g.complete(v2);
 
         checkCompletedNormally(h, null);
@@ -1150,7 +1282,7 @@ public class CompletableFutureTest exten
 
         g.complete(v2);
         checkIncomplete(h);
-        assertEquals(r.value, 0);
+        assertFalse(r.ran());
         f.complete(v1);
 
         checkCompletedNormally(h, null);
@@ -1220,7 +1352,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(f, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1241,7 +1373,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(g, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1261,7 +1393,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(g, ex);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1348,7 +1480,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(f);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1369,7 +1501,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(g);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1389,7 +1521,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(g);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1409,7 +1541,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(f);
-        assertFalse(r.ran());
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1434,7 +1566,7 @@ public class CompletableFutureTest exten
         g.complete(v2);
 
         checkCompletedNormally(h, null);
-        assertTrue(r.ran);
+        assertEquals(r.invocationCount, 1);
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
         }
@@ -1456,7 +1588,7 @@ public class CompletableFutureTest exten
         f.complete(v1);
 
         checkCompletedNormally(h, null);
-        assertTrue(r.ran);
+        assertEquals(r.invocationCount, 1);
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
         }
@@ -1496,7 +1628,7 @@ public class CompletableFutureTest exten
         final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
 
         checkCompletedNormally(h, null);
-        assertTrue(r.ran);
+        assertEquals(r.invocationCount, 1);
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
         }
@@ -1522,7 +1654,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(f, ex);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1543,7 +1675,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(g, ex);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1563,7 +1695,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(g, ex);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1583,7 +1715,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCFException(h, ex);
         checkCompletedWithWrappedCFException(f, ex);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1650,7 +1782,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(f);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1671,7 +1803,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(g);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1691,7 +1823,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(g);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(f, v1);
         }
     }
@@ -1711,7 +1843,7 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedCancellationException(h);
         checkCancelled(f);
-        assertFalse(r.ran);
+        assertEquals(r.invocationCount, 0);
         checkCompletedNormally(g, v1);
         }
     }
@@ -1720,212 +1852,931 @@ public class CompletableFutureTest exten
      * applyToEither result completes normally after normal completion
      * of either source
      */
-    public void testApplyToEither() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
-        f.complete(one);
-        checkCompletedNormally(g, two);
-        f2.complete(one);
-        checkCompletedNormally(g, two);
+    public void testApplyToEither_normalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
 
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.applyToEither(f2, inc);
-        checkCompletedNormally(g, two);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        f.complete(v1);
+        checkCompletedNormally(h, inc(v1));
+        g.complete(v2);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        checkCompletedNormally(h, inc(v1));
+        }
+    }
+
+    public void testApplyToEither_normalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        g.complete(v2);
+        checkCompletedNormally(h, inc(v2));
+        f.complete(v1);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        checkCompletedNormally(h, inc(v2));
+        }
+    }
+    public void testApplyToEither_normalCompletion3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+
+        f.complete(v1);
+        g.complete(v2);
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+
+        // unspecified behavior
+        assertTrue(Objects.equals(h.join(), inc(v1)) ||
+                   Objects.equals(h.join(), inc(v2)));
+        assertEquals(r.invocationCount, 1);
+        }
     }
 
     /**
      * applyToEither result completes exceptionally after exceptional
      * completion of either source
      */
-    public void testApplyToEither2() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
-        f.completeExceptionally(new CFException());
-        f2.complete(one);
-        checkCompletedWithWrappedCFException(g);
+    public void testApplyToEither_exceptionalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
 
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.applyToEither(f2, inc);
-        checkCompletedWithWrappedCFException(g);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+        final CFException ex = new CFException();
+
+        f.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        g.complete(v1);
+
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(g, v1);
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        }
+    }
+
+    public void testApplyToEither_exceptionalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+        final CFException ex = new CFException();
+
+        g.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        f.complete(v1);
+
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        }
+    }
+
+    public void testApplyToEither_exceptionalCompletion3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CFException ex = new CFException();
+
+        g.completeExceptionally(ex);
+        f.complete(v1);
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), inc(v1));
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCFException(h, ex);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedNormally(f, v1);
+        }
+    }
+
+    public void testApplyToEither_exceptionalCompletion4() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CFException ex = new CFException();
+
+        f.completeExceptionally(ex);
+        g.complete(v1);
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), inc(v1));
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCFException(h, ex);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedNormally(g, v1);
+        }
     }
 
     /**
      * applyToEither result completes exceptionally if action does
      */
-    public void testApplyToEither3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingFunction r = new FailingFunction();
-        CompletableFuture<Integer> g = f.applyToEither(f2, r);
-        f2.complete(two);
-        checkCompletedWithWrappedCFException(g);
+    public void testApplyToEither_actionFailed1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final FailingFunction r = new FailingFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        f.complete(v1);
+        checkCompletedWithWrappedCFException(h);
+        g.complete(v2);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        }
+    }
+
+    public void testApplyToEither_actionFailed2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final FailingFunction r = new FailingFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        g.complete(v2);
+        checkCompletedWithWrappedCFException(h);
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        }
     }
 
     /**
      * applyToEither result completes exceptionally if either source cancelled
      */
-    public void testApplyToEither4() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEither(f2, inc);
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
+    public void testApplyToEither_sourceCancelled1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        checkCompletedWithWrappedCancellationException(h);
+        g.complete(v1);
+
+        checkCancelled(f);
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(g, v1);
+        checkCompletedWithWrappedCancellationException(h);
+        }
+    }
+
+    public void testApplyToEither_sourceCancelled2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        assertTrue(g.cancel(mayInterruptIfRunning));
+        checkCompletedWithWrappedCancellationException(h);
+        f.complete(v1);
+
+        checkCancelled(g);
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCancellationException(h);
+        }
+    }
+
+    public void testApplyToEither_sourceCancelled3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+
+        assertTrue(g.cancel(mayInterruptIfRunning));
+        f.complete(v1);
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), inc(v1));
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCancelled(g);
+        checkCompletedNormally(f, v1);
+        }
+    }
+
+    public void testApplyToEither_sourceCancelled4() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncFunction r = new IncFunction();
+
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        g.complete(v1);
+        final CompletableFuture<Integer> h = m.applyToEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), inc(v1));
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCancelled(f);
+        checkCompletedNormally(g, v1);
+        }
     }
 
     /**
      * acceptEither result completes normally after normal completion
      * of either source
      */
-    public void testAcceptEither() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEither(f2, r);
-        f.complete(one);
-        checkCompletedNormally(g, null);
-        f2.complete(one);
-        checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
+    public void testAcceptEither_normalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
 
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.acceptEither(f2, r);
-        checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        f.complete(v1);
+        checkCompletedNormally(h, null);
+        assertEquals(r.value, inc(v1));
+        g.complete(v2);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        checkCompletedNormally(h, null);
+        }
+    }
+
+    public void testAcceptEither_normalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        g.complete(v2);
+        checkCompletedNormally(h, null);
+        assertEquals(r.value, inc(v2));
+        f.complete(v1);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        checkCompletedNormally(h, null);
+        }
+    }
+    public void testAcceptEither_normalCompletion3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+
+        f.complete(v1);
+        g.complete(v2);
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        checkCompletedNormally(h, null);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+
+        // unspecified behavior
+        assertTrue(Objects.equals(r.value, inc(v1)) ||
+                   Objects.equals(r.value, inc(v2)));
+        }
     }
 
     /**
      * acceptEither result completes exceptionally after exceptional
      * completion of either source
      */
-    public void testAcceptEither2() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEither(f2, r);
-        f.completeExceptionally(new CFException());
-        f2.complete(one);
-        checkCompletedWithWrappedCFException(g);
+    public void testAcceptEither_exceptionalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
 
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.acceptEither(f2, r);
-        checkCompletedWithWrappedCFException(g);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+        final CFException ex = new CFException();
+
+        f.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        g.complete(v1);
+
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(g, v1);
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        }
+    }
+
+    public void testAcceptEither_exceptionalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+        final CFException ex = new CFException();
+
+        g.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        f.complete(v1);
+
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        }
+    }
+
+    public void testAcceptEither_exceptionalCompletion3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CFException ex = new CFException();
+
+        g.completeExceptionally(ex);
+        f.complete(v1);
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+            assertEquals(inc(v1), r.value);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCFException(h, ex);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedNormally(f, v1);
+        }
+    }
+
+    public void testAcceptEither_exceptionalCompletion4() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CFException ex = new CFException();
+
+        f.completeExceptionally(ex);
+        g.complete(v1);
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+            assertEquals(inc(v1), r.value);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCFException(h, ex);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedNormally(g, v1);
+        }
     }
 
     /**
      * acceptEither result completes exceptionally if action does
      */
-    public void testAcceptEither3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingConsumer r = new FailingConsumer();
-        CompletableFuture<Void> g = f.acceptEither(f2, r);
-        f2.complete(two);
-        checkCompletedWithWrappedCFException(g);
+    public void testAcceptEither_actionFailed1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final FailingConsumer r = new FailingConsumer();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        f.complete(v1);
+        checkCompletedWithWrappedCFException(h);
+        g.complete(v2);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        }
+    }
+
+    public void testAcceptEither_actionFailed2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final FailingConsumer r = new FailingConsumer();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        g.complete(v2);
+        checkCompletedWithWrappedCFException(h);
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        }
     }
 
     /**
      * acceptEither result completes exceptionally if either source cancelled
      */
-    public void testAcceptEither4() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEither(f2, r);
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
+    public void testAcceptEither_sourceCancelled1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        checkCompletedWithWrappedCancellationException(h);
+        g.complete(v1);
+
+        checkCancelled(f);
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(g, v1);
+        checkCompletedWithWrappedCancellationException(h);
+        }
+    }
+
+    public void testAcceptEither_sourceCancelled2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        assertTrue(g.cancel(mayInterruptIfRunning));
+        checkCompletedWithWrappedCancellationException(h);
+        f.complete(v1);
+
+        checkCancelled(g);
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCancellationException(h);
+        }
+    }
+
+    public void testAcceptEither_sourceCancelled3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+
+        assertTrue(g.cancel(mayInterruptIfRunning));
+        f.complete(v1);
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+            assertEquals(inc(v1), r.value);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCancelled(g);
+        checkCompletedNormally(f, v1);
+        }
+    }
+
+    public void testAcceptEither_sourceCancelled4() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final IncAction r = new IncAction();
+
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        g.complete(v1);
+        final CompletableFuture<Void> h = m.acceptEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+            assertEquals(inc(v1), r.value);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCancelled(f);
+        checkCompletedNormally(g, v1);
+        }
     }
 
     /**
      * runAfterEither result completes normally after normal completion
      * of either source
      */
-    public void testRunAfterEither() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEither(f2, r);
-        f.complete(one);
-        checkCompletedNormally(g, null);
-        f2.complete(one);
-        checkCompletedNormally(g, null);
-        assertTrue(r.ran);
+    public void testRunAfterEither_normalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
 
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.runAfterEither(f2, r);
-        checkCompletedNormally(g, null);
-        assertTrue(r.ran);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        f.complete(v1);
+        checkCompletedNormally(h, null);
+        assertEquals(r.invocationCount, 1);
+        g.complete(v2);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        checkCompletedNormally(h, null);
+        assertEquals(r.invocationCount, 1);
+        }
+    }
+
+    public void testRunAfterEither_normalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        g.complete(v2);
+        checkCompletedNormally(h, null);
+        assertEquals(r.invocationCount, 1);
+        f.complete(v1);
+
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        checkCompletedNormally(h, null);
+        assertEquals(r.invocationCount, 1);
+        }
+    }
+    public void testRunAfterEither_normalCompletion3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+
+        f.complete(v1);
+        g.complete(v2);
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        checkCompletedNormally(h, null);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        assertEquals(r.invocationCount, 1);
+        }
     }
 
     /**
      * runAfterEither result completes exceptionally after exceptional
      * completion of either source
      */
-    public void testRunAfterEither2() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEither(f2, r);
-        f.completeExceptionally(new CFException());
-        f2.complete(one);
-        checkCompletedWithWrappedCFException(g);
+    public void testRunAfterEither_exceptionalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
 
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.runAfterEither(f2, r);
-        checkCompletedWithWrappedCFException(g);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+        final CFException ex = new CFException();
+
+        f.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        g.complete(v1);
+
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(g, v1);
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        }
+    }
+
+    public void testRunAfterEither_exceptionalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+        final CFException ex = new CFException();
+
+        g.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        f.complete(v1);
+
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedWithWrappedCFException(h, ex);
+        }
+    }
+
+    public void testRunAfterEither_exceptionalCompletion3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CFException ex = new CFException();
+
+        g.completeExceptionally(ex);
+        f.complete(v1);
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCFException(h, ex);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedNormally(f, v1);
+        }
+    }
+
+    public void testRunAfterEither_exceptionalCompletion4() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CFException ex = new CFException();
+
+        f.completeExceptionally(ex);
+        g.complete(v1);
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCFException(h, ex);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedNormally(g, v1);
+        }
     }
 
     /**
      * runAfterEither result completes exceptionally if action does
      */
-    public void testRunAfterEither3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingNoop r = new FailingNoop();
-        CompletableFuture<Void> g = f.runAfterEither(f2, r);
-        f2.complete(two);
-        checkCompletedWithWrappedCFException(g);
+    public void testRunAfterEither_actionFailed1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final FailingNoop r = new FailingNoop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        f.complete(v1);
+        checkCompletedWithWrappedCFException(h);
+        g.complete(v2);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        }
+    }
+
+    public void testRunAfterEither_actionFailed2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null })
+        for (Integer v2 : new Integer[] { 2, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final FailingNoop r = new FailingNoop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        g.complete(v2);
+        checkCompletedWithWrappedCFException(h);
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v2);
+        }
     }
 
     /**
      * runAfterEither result completes exceptionally if either source cancelled
      */
-    public void testRunAfterEither4() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEither(f2, r);
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
+    public void testRunAfterEither_sourceCancelled1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        checkCompletedWithWrappedCancellationException(h);
+        g.complete(v1);
+
+        checkCancelled(f);
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(g, v1);
+        checkCompletedWithWrappedCancellationException(h);
+        }
+    }
+
+    public void testRunAfterEither_sourceCancelled2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        assertTrue(g.cancel(mayInterruptIfRunning));
+        checkCompletedWithWrappedCancellationException(h);
+        f.complete(v1);
+
+        checkCancelled(g);
+        assertEquals(r.invocationCount, 0);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCancellationException(h);
+        }
+    }
+
+    public void testRunAfterEither_sourceCancelled3() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+
+        assertTrue(g.cancel(mayInterruptIfRunning));
+        f.complete(v1);
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCancelled(g);
+        checkCompletedNormally(f, v1);
+        }
+    }
+
+    public void testRunAfterEither_sourceCancelled4() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null }) {
+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final Noop r = new Noop();
+
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        g.complete(v1);
+        final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
+
+        // unspecified behavior
+        Integer v;
+        try {
+            assertEquals(h.join(), null);
+            assertEquals(r.invocationCount, 1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h);
+            assertEquals(r.invocationCount, 0);
+        }
+
+        checkCancelled(f);
+        checkCompletedNormally(g, v1);
+        }
     }
 
     /**
@@ -2113,7 +2964,7 @@ public class CompletableFutureTest exten
         CompletableFuture<Void> g = f.thenAcceptAsync(r);
         f.complete(one);
         checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
+        assertEquals(r.value, (Integer) 2);
     }
 
     /**
@@ -2151,222 +3002,6 @@ public class CompletableFutureTest exten
     }
 
     /**
-     * applyToEitherAsync result completes normally after normal
-     * completion of sources
-     */
-    public void testApplyToEitherAsync() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
-        f.complete(one);
-        checkCompletedNormally(g, two);
-
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.applyToEitherAsync(f2, inc);
-        checkCompletedNormally(g, two);
-    }
-
-    /**
-     * applyToEitherAsync result completes exceptionally after exceptional
-     * completion of source
-     */
-    public void testApplyToEitherAsync2() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(g);
-
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.applyToEitherAsync(f2, inc);
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * applyToEitherAsync result completes exceptionally if action does
-     */
-    public void testApplyToEitherAsync3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingFunction r = new FailingFunction();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * applyToEitherAsync result completes exceptionally if either source cancelled
-     */
-    public void testApplyToEitherAsync4() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc);
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        g = f.applyToEitherAsync(f2, inc);
-        checkCompletedWithWrappedCancellationException(g);
-    }
-
-    /**
-     * acceptEitherAsync result completes normally after normal
-     * completion of sources
-     */
-    public void testAcceptEitherAsync() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
-
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.acceptEitherAsync(f2, r);
-        checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
-    }
-
-    /**
-     * acceptEitherAsync result completes exceptionally after exceptional
-     * completion of source
-     */
-    public void testAcceptEitherAsync2() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(g);
-
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.acceptEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * acceptEitherAsync result completes exceptionally if action does
-     */
-    public void testAcceptEitherAsync3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingConsumer r = new FailingConsumer();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * acceptEitherAsync result completes exceptionally if either
-     * source cancelled
-     */
-    public void testAcceptEitherAsync4() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        g = f.acceptEitherAsync(f2, r);
-        checkCompletedWithWrappedCancellationException(g);
-    }
-
-    /**
-     * runAfterEitherAsync result completes normally after normal
-     * completion of sources
-     */
-    public void testRunAfterEitherAsync() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedNormally(g, null);
-        assertTrue(r.ran);
-
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.runAfterEitherAsync(f2, r);
-        checkCompletedNormally(g, null);
-        assertTrue(r.ran);
-    }
-
-    /**
-     * runAfterEitherAsync result completes exceptionally after exceptional
-     * completion of source
-     */
-    public void testRunAfterEitherAsync2() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(g);
-
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.runAfterEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * runAfterEitherAsync result completes exceptionally if action does
-     */
-    public void testRunAfterEitherAsync3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingNoop r = new FailingNoop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * runAfterEitherAsync result completes exceptionally if either
-     * source cancelled
-     */
-    public void testRunAfterEitherAsync4() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        g = f.runAfterEitherAsync(f2, r);
-        checkCompletedWithWrappedCancellationException(g);
-    }
-
-    /**
      * thenComposeAsync result completes normally after normal
      * completion of source
      */
@@ -2552,7 +3187,7 @@ public class CompletableFutureTest exten
         CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
         f.complete(one);
         checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
+        assertEquals(r.value, (Integer) 2);
     }
 
     /**
@@ -2590,222 +3225,6 @@ public class CompletableFutureTest exten
     }
 
     /**
-     * applyToEitherAsync result completes normally after normal
-     * completion of sources
-     */
-    public void testApplyToEitherAsyncE() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedNormally(g, two);
-
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
-        checkCompletedNormally(g, two);
-    }
-
-    /**
-     * applyToEitherAsync result completes exceptionally after exceptional
-     * completion of source
-     */
-    public void testApplyToEitherAsync2E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(g);
-
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * applyToEitherAsync result completes exceptionally if action does
-     */
-    public void testApplyToEitherAsync3E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingFunction r = new FailingFunction();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * applyToEitherAsync result completes exceptionally if either source cancelled
-     */
-    public void testApplyToEitherAsync4E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        CompletableFuture<Integer> g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        g = f.applyToEitherAsync(f2, inc, new ThreadExecutor());
-        checkCompletedWithWrappedCancellationException(g);
-    }
-
-    /**
-     * acceptEitherAsync result completes normally after normal
-     * completion of sources
-     */
-    public void testAcceptEitherAsyncE() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
-
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        checkCompletedNormally(g, null);
-        assertEquals(r.value, 2);
-    }
-
-    /**
-     * acceptEitherAsync result completes exceptionally after exceptional
-     * completion of source
-     */
-    public void testAcceptEitherAsync2E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(g);
-
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * acceptEitherAsync result completes exceptionally if action does
-     */
-    public void testAcceptEitherAsync3E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingConsumer r = new FailingConsumer();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * acceptEitherAsync result completes exceptionally if either
-     * source cancelled
-     */
-    public void testAcceptEitherAsync4E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        IncAction r = new IncAction();
-        CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-
-        r = new IncAction();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
-        checkCompletedWithWrappedCancellationException(g);
-    }
-
-    /**
-     * runAfterEitherAsync result completes normally after normal
-     * completion of sources
-     */
-    public void testRunAfterEitherAsyncE() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedNormally(g, null);
-        assertTrue(r.ran);
-
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f.complete(one);
-        f2 = new CompletableFuture<>();
-        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        checkCompletedNormally(g, null);
-        assertTrue(r.ran);
-    }
-
-    /**
-     * runAfterEitherAsync result completes exceptionally after exceptional
-     * completion of source
-     */
-    public void testRunAfterEitherAsync2E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(g);
-
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        f2.completeExceptionally(new CFException());
-        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * runAfterEitherAsync result completes exceptionally if action does
-     */
-    public void testRunAfterEitherAsync3E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        FailingNoop r = new FailingNoop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        f.complete(one);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * runAfterEitherAsync result completes exceptionally if either
-     * source cancelled
-     */
-    public void testRunAfterEitherAsync4E() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> f2 = new CompletableFuture<>();
-        Noop r = new Noop();
-        CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        assertTrue(f.cancel(true));
-        checkCompletedWithWrappedCancellationException(g);
-
-        r = new Noop();
-        f = new CompletableFuture<>();
-        f2 = new CompletableFuture<>();
-        assertTrue(f2.cancel(true));
-        g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
-        checkCompletedWithWrappedCancellationException(g);
-    }
-
-    /**
      * thenComposeAsync result completes normally after normal
      * completion of source
      */
@@ -3049,137 +3468,97 @@ public class CompletableFutureTest exten
      * whenComplete action executes on normal completion, propagating
      * source result.
      */
-    public void testWhenComplete1() {
+    public void testWhenComplete_normalCompletion1() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
         final AtomicInteger a = new AtomicInteger();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
-        f.complete(three);
-        checkCompletedNormally(f, three);
-        checkCompletedNormally(g, three);
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g =
+            m.whenComplete(f,
+                           (Integer x, Throwable t) -> {
+                               threadAssertSame(x, v1);
+                               threadAssertNull(t);
+                               a.getAndIncrement();
+                           });
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v1);
         assertEquals(a.get(), 1);
+        }
     }
 
     /**
      * whenComplete action executes on exceptional completion, propagating
      * source result.
      */
-    public void testWhenComplete2() {
+    public void testWhenComplete_exceptionalCompletion() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
+
         final AtomicInteger a = new AtomicInteger();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
-        f.completeExceptionally(new CFException());
-        assertTrue(f.isCompletedExceptionally());
-        assertTrue(g.isCompletedExceptionally());
+        final CFException ex = new CFException();
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = m.whenComplete
+            (f,
+             (Integer x, Throwable t) -> {
+                threadAssertNull(x);
+                threadAssertSame(t, ex);
+                a.getAndIncrement();
+            });
+        f.completeExceptionally(ex);
+        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedCFException(g, ex);
         assertEquals(a.get(), 1);
+        }
     }
 
     /**
      * If a whenComplete action throws an exception when triggered by
      * a normal completion, it completes exceptionally
      */
-    public void testWhenComplete3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenComplete((Integer x, Throwable t) ->
-                           { throw new CFException(); } );
-        f.complete(three);
-        checkCompletedNormally(f, three);
-        assertTrue(g.isCompletedExceptionally());
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * whenCompleteAsync action executes on normal completion, propagating
-     * source result.
-     */
-    public void testWhenCompleteAsync1() {
-        final AtomicInteger a = new AtomicInteger();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
-        f.complete(three);
-        checkCompletedNormally(f, three);
-        checkCompletedNormally(g, three);
-        assertEquals(a.get(), 1);
-    }
-
-    /**
-     * whenCompleteAsync action executes on exceptional completion, propagating
-     * source result.
-     */
-    public void testWhenCompleteAsync2() {
-        final AtomicInteger a = new AtomicInteger();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(f);
-        checkCompletedWithWrappedCFException(g);
-    }
-
-    /**
-     * If a whenCompleteAsync action throws an exception when
-     * triggered by a normal completion, it completes exceptionally
-     */
-    public void testWhenCompleteAsync3() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenCompleteAsync((Integer x, Throwable t) ->
-                           { throw new CFException(); } );
-        f.complete(three);
-        checkCompletedNormally(f, three);
-        checkCompletedWithWrappedCFException(g);
-    }
+    public void testWhenComplete_actionFailed() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
 
-    /**
-     * whenCompleteAsync action executes on normal completion, propagating
-     * source result.
-     */
-    public void testWhenCompleteAsync1e() {
-        final AtomicInteger a = new AtomicInteger();
-        ThreadExecutor exec = new ThreadExecutor();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
-                                exec);
-        f.complete(three);
-        checkCompletedNormally(f, three);
-        checkCompletedNormally(g, three);
-        assertEquals(a.get(), 1);
+        final CFException ex = new CFException();
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = m.whenComplete
+            (f,
+             (Integer x, Throwable t) -> {
+                threadAssertSame(x, v1);
+                threadAssertNull(t);
+                throw ex;
+            });
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedCFException(g, ex);
+        }
     }
 
     /**
-     * whenCompleteAsync action executes on exceptional completion, propagating
-     * source result.
+     * If a whenComplete action throws an exception when triggered by
+     * a source completion that also throws an exception, the source
+     * exception takes precedence.
      */
-    public void testWhenCompleteAsync2e() {
-        final AtomicInteger a = new AtomicInteger();
-        ThreadExecutor exec = new ThreadExecutor();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
-                                exec);
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(f);
-        checkCompletedWithWrappedCFException(g);
-    }
+    public void testWhenComplete_actionFailedSourceFailed() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (Integer v1 : new Integer[] { 1, null }) {
 
-    /**
-     * If a whenCompleteAsync action throws an exception when triggered
-     * by a normal completion, it completes exceptionally
-     */
-    public void testWhenCompleteAsync3e() {
-        ThreadExecutor exec = new ThreadExecutor();
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        CompletableFuture<Integer> g =
-            f.whenCompleteAsync((Integer x, Throwable t) ->
-                                { throw new CFException(); },
-                                exec);
-        f.complete(three);
-        checkCompletedNormally(f, three);
-        checkCompletedWithWrappedCFException(g);
+        final CFException ex1 = new CFException();
+        final CFException ex2 = new CFException();
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = m.whenComplete
+            (f,
+             (Integer x, Throwable t) -> {
+                threadAssertSame(t, ex1);
+                threadAssertNull(x);
+                throw ex2;
+            });
+        f.completeExceptionally(ex1);
+        checkCompletedWithWrappedCFException(f, ex1);
+        checkCompletedWithWrappedCFException(g, ex1);
+        }
     }
 
     /**