--- jsr166/src/test/tck/CompletableFutureTest.java	2014/06/06 17:41:02	1.65
+++ jsr166/src/test/tck/CompletableFutureTest.java	2014/06/06 21:19:22	1.74
@@ -105,8 +105,8 @@ public class CompletableFutureTest exten
         assertTrue(f.toString().contains("[Completed exceptionally]"));
     }
 
-    void checkCompletedWithWrappedCFException(CompletableFuture<?> f,
-                                              CFException ex) {
+    <U> void checkCompletedExceptionallyWithRootCause(CompletableFuture<U> f,
+                                                      Throwable ex) {
         try {
             f.get(LONG_DELAY_MS, MILLISECONDS);
             shouldThrow();
@@ -131,11 +131,32 @@ public class CompletableFutureTest exten
         } catch (ExecutionException success) {
             assertSame(ex, success.getCause());
         } catch (Throwable fail) { threadUnexpectedException(fail); }
+
         assertTrue(f.isDone());
         assertFalse(f.isCancelled());
         assertTrue(f.toString().contains("[Completed exceptionally]"));
     }
 
+    <U> void checkCompletedWithWrappedException(CompletableFuture<U> f,
+                                                Throwable ex) {
+        checkCompletedExceptionallyWithRootCause(f, ex);
+        try {
+            CompletableFuture<Throwable> spy = f.handle
+                ((U u, Throwable t) -> t);
+            assertTrue(spy.join() instanceof CompletionException);
+            assertSame(ex, spy.join().getCause());
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
+    }
+
+    <U> void checkCompletedExceptionally(CompletableFuture<U> f, Throwable ex) {
+        checkCompletedExceptionallyWithRootCause(f, ex);
+        try {
+            CompletableFuture<Throwable> spy = f.handle
+                ((U u, Throwable t) -> t);
+            assertSame(ex, spy.join());
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
+    }
+
     void checkCancelled(CompletableFuture<?> f) {
         try {
             f.get(LONG_DELAY_MS, MILLISECONDS);
@@ -218,9 +239,10 @@ public class CompletableFutureTest exten
      */
     public void testCompleteExceptionally() {
         CompletableFuture<Integer> f = new CompletableFuture<>();
+        CFException ex = new CFException();
         checkIncomplete(f);
-        f.completeExceptionally(new CFException());
-        checkCompletedWithWrappedCFException(f);
+        f.completeExceptionally(ex);
+        checkCompletedExceptionally(f, ex);
     }
 
     /**
@@ -261,22 +283,35 @@ public class CompletableFutureTest exten
      * obtrudeException forces completion with given exception
      */
     public void testObtrudeException() {
-        CompletableFuture<Integer> f = new CompletableFuture<>();
-        checkIncomplete(f);
-        f.complete(one);
-        checkCompletedNormally(f, one);
-        f.obtrudeException(new CFException());
-        checkCompletedWithWrappedCFException(f);
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        CFException ex;
+        CompletableFuture<Integer> f;
+
         f = new CompletableFuture<>();
-        f.obtrudeException(new CFException());
-        checkCompletedWithWrappedCFException(f);
+        f.complete(v1);
+        for (int i = 0; i < 2; i++) {
+            f.obtrudeException(ex = new CFException());
+            checkCompletedExceptionally(f, ex);
+        }
+
+        f = new CompletableFuture<>();
+        for (int i = 0; i < 2; i++) {
+            f.obtrudeException(ex = new CFException());
+            checkCompletedExceptionally(f, ex);
+        }
+
         f = new CompletableFuture<>();
+        f.completeExceptionally(ex = new CFException());
+        f.obtrudeValue(v1);
+        checkCompletedNormally(f, v1);
+        f.obtrudeException(ex = new CFException());
+        checkCompletedExceptionally(f, ex);
         f.completeExceptionally(new CFException());
-        f.obtrudeValue(four);
-        checkCompletedNormally(f, four);
-        f.obtrudeException(new CFException());
-        checkCompletedWithWrappedCFException(f);
-    }
+        checkCompletedExceptionally(f, ex);
+        f.complete(v1);
+        checkCompletedExceptionally(f, ex);
+    }}
 
     /**
      * getNumberOfDependents returns number of dependent tasks
@@ -310,6 +345,14 @@ public class CompletableFutureTest exten
         f = new CompletableFuture<String>();
         f.completeExceptionally(new IndexOutOfBoundsException());
         assertTrue(f.toString().contains("[Completed exceptionally]"));
+
+        f = new CompletableFuture<String>();
+        f.cancel(true);
+        assertTrue(f.toString().contains("[Completed exceptionally]"));
+
+        f = new CompletableFuture<String>();
+        f.cancel(false);
+        assertTrue(f.toString().contains("[Completed exceptionally]"));
     }
 
     /**
@@ -852,7 +895,7 @@ public class CompletableFutureTest exten
             });
         if (createIncomplete) f.completeExceptionally(ex1);
 
-        checkCompletedWithWrappedCFException(g, ex2);
+        checkCompletedWithWrappedException(g, ex2);
         assertEquals(1, a.get());
     }}
 
@@ -909,7 +952,7 @@ public class CompletableFutureTest exten
         if (createIncomplete) f.completeExceptionally(ex);
 
         checkCompletedNormally(g, v1);
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedExceptionally(f, ex);
         assertEquals(1, a.get());
     }}
 
@@ -965,8 +1008,8 @@ public class CompletableFutureTest exten
             });
         if (createIncomplete) f.completeExceptionally(ex1);
 
-        checkCompletedWithWrappedCFException(g, ex2);
-        checkCompletedWithWrappedCFException(f, ex1);
+        checkCompletedWithWrappedException(g, ex2);
+        checkCompletedExceptionally(f, ex1);
         assertEquals(1, a.get());
     }}
 
@@ -990,7 +1033,7 @@ public class CompletableFutureTest exten
             });
         if (createIncomplete) f.complete(v1);
 
-        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedWithWrappedException(g, ex);
         checkCompletedNormally(f, v1);
         assertEquals(1, a.get());
     }}
@@ -1104,8 +1147,8 @@ public class CompletableFutureTest exten
             f.completeExceptionally(ex);
         }
 
-        checkCompletedWithWrappedCFException(g, ex);
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedException(g, ex);
+        checkCompletedExceptionally(f, ex);
         r.assertNotInvoked();
     }}
 
@@ -1171,7 +1214,7 @@ public class CompletableFutureTest exten
 
         checkCompletedNormally(g, inc(v1));
         checkCompletedNormally(f, v1);
-        r.assertInvoked();
+        r.assertValue(inc(v1));
     }}
 
     /**
@@ -1192,8 +1235,8 @@ public class CompletableFutureTest exten
             f.completeExceptionally(ex);
         }
 
-        checkCompletedWithWrappedCFException(g, ex);
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedException(g, ex);
+        checkCompletedExceptionally(f, ex);
         r.assertNotInvoked();
     }}
 
@@ -1280,8 +1323,8 @@ public class CompletableFutureTest exten
             f.completeExceptionally(ex);
         }
 
-        checkCompletedWithWrappedCFException(g, ex);
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedException(g, ex);
+        checkCompletedExceptionally(f, ex);
         r.assertNotInvoked();
     }}
 
@@ -1356,7 +1399,7 @@ public class CompletableFutureTest exten
         checkCompletedNormally(h, subtract(v1, v2));
         checkCompletedNormally(f, v1);
         checkCompletedNormally(g, v2);
-        r.assertInvoked();
+        r.assertValue(subtract(v1, v2));
     }}
 
     /**
@@ -1383,10 +1426,10 @@ public class CompletableFutureTest exten
             (!fFirst ? f : g).completeExceptionally(ex);
         }
 
-        checkCompletedWithWrappedCFException(h, ex);
+        checkCompletedWithWrappedException(h, ex);
         r.assertNotInvoked();
         checkCompletedNormally(fFirst ? f : g, v1);
-        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
+        checkCompletedExceptionally(!fFirst ? f : g, ex);
     }}
 
     /**
@@ -1500,10 +1543,10 @@ public class CompletableFutureTest exten
             (!fFirst ? f : g).completeExceptionally(ex);
         }
 
-        checkCompletedWithWrappedCFException(h, ex);
+        checkCompletedWithWrappedException(h, ex);
         r.assertNotInvoked();
         checkCompletedNormally(fFirst ? f : g, v1);
-        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
+        checkCompletedExceptionally(!fFirst ? f : g, ex);
     }}
 
     /**
@@ -1617,10 +1660,10 @@ public class CompletableFutureTest exten
             (!fFirst ? f : g).completeExceptionally(ex);
         }
 
-        checkCompletedWithWrappedCFException(h, ex);
+        checkCompletedWithWrappedException(h, ex);
         r.assertNotInvoked();
         checkCompletedNormally(fFirst ? f : g, v1);
-        checkCompletedWithWrappedCFException(!fFirst ? f : g, ex);
+        checkCompletedExceptionally(!fFirst ? f : g, ex);
     }}
 
     /**
@@ -1752,12 +1795,12 @@ public class CompletableFutureTest exten
         rs[0].assertNotInvoked();
         rs[1].assertNotInvoked();
         f.completeExceptionally(ex);
-        checkCompletedWithWrappedCFException(h0, ex);
-        checkCompletedWithWrappedCFException(h1, ex);
+        checkCompletedWithWrappedException(h0, ex);
+        checkCompletedWithWrappedException(h1, ex);
         final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
         final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
-        checkCompletedWithWrappedCFException(h2, ex);
-        checkCompletedWithWrappedCFException(h3, ex);
+        checkCompletedWithWrappedException(h2, ex);
+        checkCompletedWithWrappedException(h3, ex);
         g.complete(v1);
 
         // unspecified behavior - both source completions available
@@ -1765,29 +1808,86 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
         try {
             assertEquals(inc(v1), h4.join());
-            rs[4].assertInvoked();
+            rs[4].assertValue(inc(v1));
         } catch (CompletionException ok) {
-            checkCompletedWithWrappedCFException(h4, ex);
+            checkCompletedWithWrappedException(h4, ex);
             rs[4].assertNotInvoked();
         }
         try {
             assertEquals(inc(v1), h5.join());
-            rs[5].assertInvoked();
+            rs[5].assertValue(inc(v1));
         } catch (CompletionException ok) {
-            checkCompletedWithWrappedCFException(h5, ex);
+            checkCompletedWithWrappedException(h5, ex);
             rs[5].assertNotInvoked();
         }
 
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedExceptionally(f, ex);
         checkCompletedNormally(g, v1);
-        checkCompletedWithWrappedCFException(h0, ex);
-        checkCompletedWithWrappedCFException(h1, ex);
-        checkCompletedWithWrappedCFException(h2, ex);
-        checkCompletedWithWrappedCFException(h3, ex);
-        checkCompletedWithWrappedCFException(h4, ex);
+        checkCompletedWithWrappedException(h0, ex);
+        checkCompletedWithWrappedException(h1, ex);
+        checkCompletedWithWrappedException(h2, ex);
+        checkCompletedWithWrappedException(h3, ex);
+        checkCompletedWithWrappedException(h4, ex);
         for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
     }}
 
+    public void testApplyToEither_exceptionalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean fFirst : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final CFException ex = new CFException();
+        final IncFunction[] rs = new IncFunction[6];
+        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
+
+        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
+        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
+        if (fFirst) {
+            f.complete(v1);
+            g.completeExceptionally(ex);
+        } else {
+            g.completeExceptionally(ex);
+            f.complete(v1);
+        }
+        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
+        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
+
+        // unspecified behavior - both source completions available
+        try {
+            assertEquals(inc(v1), h0.join());
+            rs[0].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h0, ex);
+            rs[0].assertNotInvoked();
+        }
+        try {
+            assertEquals(inc(v1), h1.join());
+            rs[1].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h1, ex);
+            rs[1].assertNotInvoked();
+        }
+        try {
+            assertEquals(inc(v1), h2.join());
+            rs[2].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h2, ex);
+            rs[2].assertNotInvoked();
+        }
+        try {
+            assertEquals(inc(v1), h3.join());
+            rs[3].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h3, ex);
+            rs[3].assertNotInvoked();
+        }
+
+        checkCompletedNormally(f, v1);
+        checkCompletedExceptionally(g, ex);
+    }}
+
     /**
      * applyToEither result completes exceptionally if either source cancelled
      */
@@ -1821,14 +1921,14 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> h5 = m.applyToEither(g, f, rs[5]);
         try {
             assertEquals(inc(v1), h4.join());
-            rs[4].assertInvoked();
+            rs[4].assertValue(inc(v1));
         } catch (CompletionException ok) {
             checkCompletedWithWrappedCancellationException(h4);
             rs[4].assertNotInvoked();
         }
         try {
             assertEquals(inc(v1), h5.join());
-            rs[5].assertInvoked();
+            rs[5].assertValue(inc(v1));
         } catch (CompletionException ok) {
             checkCompletedWithWrappedCancellationException(h5);
             rs[5].assertNotInvoked();
@@ -1843,6 +1943,63 @@ public class CompletableFutureTest exten
         for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
     }}
 
+    public void testApplyToEither_sourceCancelled2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (boolean fFirst : 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[] rs = new IncFunction[6];
+        for (int i = 0; i < rs.length; i++) rs[i] = new IncFunction(m);
+
+        final CompletableFuture<Integer> h0 = m.applyToEither(f, g, rs[0]);
+        final CompletableFuture<Integer> h1 = m.applyToEither(g, f, rs[1]);
+        if (fFirst) {
+            f.complete(v1);
+            g.cancel(mayInterruptIfRunning);
+        } else {
+            g.cancel(mayInterruptIfRunning);
+            f.complete(v1);
+        }
+        final CompletableFuture<Integer> h2 = m.applyToEither(f, g, rs[2]);
+        final CompletableFuture<Integer> h3 = m.applyToEither(g, f, rs[3]);
+
+        // unspecified behavior - both source completions available
+        try {
+            assertEquals(inc(v1), h0.join());
+            rs[0].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h0);
+            rs[0].assertNotInvoked();
+        }
+        try {
+            assertEquals(inc(v1), h1.join());
+            rs[1].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h1);
+            rs[1].assertNotInvoked();
+        }
+        try {
+            assertEquals(inc(v1), h2.join());
+            rs[2].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h2);
+            rs[2].assertNotInvoked();
+        }
+        try {
+            assertEquals(inc(v1), h3.join());
+            rs[3].assertValue(inc(v1));
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedCancellationException(h3);
+            rs[3].assertNotInvoked();
+        }
+
+        checkCompletedNormally(f, v1);
+        checkCancelled(g);
+    }}
+
     /**
      * applyToEither result completes exceptionally if action does
      */
@@ -1957,12 +2114,12 @@ public class CompletableFutureTest exten
         rs[0].assertNotInvoked();
         rs[1].assertNotInvoked();
         f.completeExceptionally(ex);
-        checkCompletedWithWrappedCFException(h0, ex);
-        checkCompletedWithWrappedCFException(h1, ex);
+        checkCompletedWithWrappedException(h0, ex);
+        checkCompletedWithWrappedException(h1, ex);
         final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
         final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
-        checkCompletedWithWrappedCFException(h2, ex);
-        checkCompletedWithWrappedCFException(h3, ex);
+        checkCompletedWithWrappedException(h2, ex);
+        checkCompletedWithWrappedException(h3, ex);
 
         g.complete(v1);
 
@@ -1973,27 +2130,84 @@ public class CompletableFutureTest exten
             assertNull(h4.join());
             rs[4].assertValue(v1);
         } catch (CompletionException ok) {
-            checkCompletedWithWrappedCFException(h4, ex);
+            checkCompletedWithWrappedException(h4, ex);
             rs[4].assertNotInvoked();
         }
         try {
             assertNull(h5.join());
             rs[5].assertValue(v1);
         } catch (CompletionException ok) {
-            checkCompletedWithWrappedCFException(h5, ex);
+            checkCompletedWithWrappedException(h5, ex);
             rs[5].assertNotInvoked();
         }
 
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedExceptionally(f, ex);
         checkCompletedNormally(g, v1);
-        checkCompletedWithWrappedCFException(h0, ex);
-        checkCompletedWithWrappedCFException(h1, ex);
-        checkCompletedWithWrappedCFException(h2, ex);
-        checkCompletedWithWrappedCFException(h3, ex);
-        checkCompletedWithWrappedCFException(h4, ex);
+        checkCompletedWithWrappedException(h0, ex);
+        checkCompletedWithWrappedException(h1, ex);
+        checkCompletedWithWrappedException(h2, ex);
+        checkCompletedWithWrappedException(h3, ex);
+        checkCompletedWithWrappedException(h4, ex);
         for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
     }}
 
+    public void testAcceptEither_exceptionalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean fFirst : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final CFException ex = new CFException();
+        final NoopConsumer[] rs = new NoopConsumer[6];
+        for (int i = 0; i < rs.length; i++) rs[i] = new NoopConsumer(m);
+
+        final CompletableFuture<Void> h0 = m.acceptEither(f, g, rs[0]);
+        final CompletableFuture<Void> h1 = m.acceptEither(g, f, rs[1]);
+        if (fFirst) {
+            f.complete(v1);
+            g.completeExceptionally(ex);
+        } else {
+            g.completeExceptionally(ex);
+            f.complete(v1);
+        }
+        final CompletableFuture<Void> h2 = m.acceptEither(f, g, rs[2]);
+        final CompletableFuture<Void> h3 = m.acceptEither(g, f, rs[3]);
+
+        // unspecified behavior - both source completions available
+        try {
+            assertEquals(null, h0.join());
+            rs[0].assertValue(v1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h0, ex);
+            rs[0].assertNotInvoked();
+        }
+        try {
+            assertEquals(null, h1.join());
+            rs[1].assertValue(v1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h1, ex);
+            rs[1].assertNotInvoked();
+        }
+        try {
+            assertEquals(null, h2.join());
+            rs[2].assertValue(v1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h2, ex);
+            rs[2].assertNotInvoked();
+        }
+        try {
+            assertEquals(null, h3.join());
+            rs[3].assertValue(v1);
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h3, ex);
+            rs[3].assertNotInvoked();
+        }
+
+        checkCompletedNormally(f, v1);
+        checkCompletedExceptionally(g, ex);
+    }}
+
     /**
      * acceptEither result completes exceptionally if either source cancelled
      */
@@ -2160,12 +2374,12 @@ public class CompletableFutureTest exten
         rs[0].assertNotInvoked();
         rs[1].assertNotInvoked();
         f.completeExceptionally(ex);
-        checkCompletedWithWrappedCFException(h0, ex);
-        checkCompletedWithWrappedCFException(h1, ex);
+        checkCompletedWithWrappedException(h0, ex);
+        checkCompletedWithWrappedException(h1, ex);
         final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
         final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
-        checkCompletedWithWrappedCFException(h2, ex);
-        checkCompletedWithWrappedCFException(h3, ex);
+        checkCompletedWithWrappedException(h2, ex);
+        checkCompletedWithWrappedException(h3, ex);
 
         g.complete(v1);
 
@@ -2176,27 +2390,84 @@ public class CompletableFutureTest exten
             assertNull(h4.join());
             rs[4].assertInvoked();
         } catch (CompletionException ok) {
-            checkCompletedWithWrappedCFException(h4, ex);
+            checkCompletedWithWrappedException(h4, ex);
             rs[4].assertNotInvoked();
         }
         try {
             assertNull(h5.join());
             rs[5].assertInvoked();
         } catch (CompletionException ok) {
-            checkCompletedWithWrappedCFException(h5, ex);
+            checkCompletedWithWrappedException(h5, ex);
             rs[5].assertNotInvoked();
         }
 
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedExceptionally(f, ex);
         checkCompletedNormally(g, v1);
-        checkCompletedWithWrappedCFException(h0, ex);
-        checkCompletedWithWrappedCFException(h1, ex);
-        checkCompletedWithWrappedCFException(h2, ex);
-        checkCompletedWithWrappedCFException(h3, ex);
-        checkCompletedWithWrappedCFException(h4, ex);
+        checkCompletedWithWrappedException(h0, ex);
+        checkCompletedWithWrappedException(h1, ex);
+        checkCompletedWithWrappedException(h2, ex);
+        checkCompletedWithWrappedException(h3, ex);
+        checkCompletedWithWrappedException(h4, ex);
         for (int i = 0; i < 4; i++) rs[i].assertNotInvoked();
     }}
 
+    public void testRunAfterEither_exceptionalCompletion2() {
+        for (ExecutionMode m : ExecutionMode.values())
+        for (boolean fFirst : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
+        final CFException ex = new CFException();
+        final Noop[] rs = new Noop[6];
+        for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
+
+        final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
+        final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
+        if (fFirst) {
+            f.complete(v1);
+            g.completeExceptionally(ex);
+        } else {
+            g.completeExceptionally(ex);
+            f.complete(v1);
+        }
+        final CompletableFuture<Void> h2 = m.runAfterEither(f, g, rs[2]);
+        final CompletableFuture<Void> h3 = m.runAfterEither(g, f, rs[3]);
+
+        // unspecified behavior - both source completions available
+        try {
+            assertEquals(null, h0.join());
+            rs[0].assertInvoked();
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h0, ex);
+            rs[0].assertNotInvoked();
+        }
+        try {
+            assertEquals(null, h1.join());
+            rs[1].assertInvoked();
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h1, ex);
+            rs[1].assertNotInvoked();
+        }
+        try {
+            assertEquals(null, h2.join());
+            rs[2].assertInvoked();
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h2, ex);
+            rs[2].assertNotInvoked();
+        }
+        try {
+            assertEquals(null, h3.join());
+            rs[3].assertInvoked();
+        } catch (CompletionException ok) {
+            checkCompletedWithWrappedException(h3, ex);
+            rs[3].assertNotInvoked();
+        }
+
+        checkCompletedNormally(f, v1);
+        checkCompletedExceptionally(g, ex);
+    }}
+
     /**
      * runAfterEither result completes exceptionally if either source cancelled
      */
@@ -2303,7 +2574,7 @@ public class CompletableFutureTest exten
 
         checkCompletedNormally(g, inc(v1));
         checkCompletedNormally(f, v1);
-        r.assertInvoked();
+        r.assertValue(v1);
     }}
 
     /**
@@ -2321,8 +2592,8 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> g = m.thenCompose(f, r);
         if (createIncomplete) f.completeExceptionally(ex);
 
-        checkCompletedWithWrappedCFException(g, ex);
-        checkCompletedWithWrappedCFException(f, ex);
+        checkCompletedWithWrappedException(g, ex);
+        checkCompletedExceptionally(f, ex);
         r.assertNotInvoked();
     }}
 
@@ -2593,6 +2864,7 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
              (Integer x, Throwable t) -> {
+                m.checkExecutionMode();
                 threadAssertSame(x, v1);
                 threadAssertNull(t);
                 a.getAndIncrement();
@@ -2620,13 +2892,14 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
              (Integer x, Throwable t) -> {
+                m.checkExecutionMode();
                 threadAssertNull(x);
                 threadAssertSame(t, ex);
                 a.getAndIncrement();
             });
         if (createIncomplete) f.completeExceptionally(ex);
-        checkCompletedWithWrappedCFException(f, ex);
-        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedExceptionally(f, ex);
+        checkCompletedWithWrappedException(g, ex);
         assertEquals(1, a.get());
     }}
 
@@ -2645,13 +2918,13 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
              (Integer x, Throwable t) -> {
+                m.checkExecutionMode();
                 threadAssertNull(x);
                 threadAssertTrue(t instanceof CancellationException);
                 a.getAndIncrement();
             });
         if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
 
-        //try { g.join(); } catch (Throwable t) { throw new Error(t); }
         checkCompletedWithWrappedCancellationException(g);
         checkCancelled(f);
         assertEquals(1, a.get());
@@ -2673,6 +2946,7 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
              (Integer x, Throwable t) -> {
+                m.checkExecutionMode();
                 threadAssertSame(x, v1);
                 threadAssertNull(t);
                 a.getAndIncrement();
@@ -2680,7 +2954,7 @@ public class CompletableFutureTest exten
             });
         if (createIncomplete) f.complete(v1);
         checkCompletedNormally(f, v1);
-        checkCompletedWithWrappedCFException(g, ex);
+        checkCompletedWithWrappedException(g, ex);
         assertEquals(1, a.get());
     }}
 
@@ -2703,6 +2977,7 @@ public class CompletableFutureTest exten
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
              (Integer x, Throwable t) -> {
+                m.checkExecutionMode();
                 threadAssertSame(t, ex1);
                 threadAssertNull(x);
                 a.getAndIncrement();
@@ -2710,8 +2985,8 @@ public class CompletableFutureTest exten
             });
         if (createIncomplete) f.completeExceptionally(ex1);
 
-        checkCompletedWithWrappedCFException(f, ex1);
-        checkCompletedWithWrappedCFException(g, ex1);
+        checkCompletedExceptionally(f, ex1);
+        checkCompletedWithWrappedException(g, ex1);
         assertEquals(1, a.get());
     }}