--- jsr166/src/test/tck/CompletableFutureTest.java	2014/06/16 18:04:07	1.82
+++ jsr166/src/test/tck/CompletableFutureTest.java	2014/06/16 21:34:49	1.89
@@ -2922,13 +2922,13 @@ public class CompletableFutureTest exten
      * when all components complete normally
      */
     public void testAllOf_normal() throws Exception {
-        for (int k = 1; k < 20; ++k) {
+        for (int k = 1; k < 10; k++) {
             CompletableFuture<Integer>[] fs
                 = (CompletableFuture<Integer>[]) new CompletableFuture[k];
-            for (int i = 0; i < k; ++i)
+            for (int i = 0; i < k; i++)
                 fs[i] = new CompletableFuture<>();
             CompletableFuture<Void> f = CompletableFuture.allOf(fs);
-            for (int i = 0; i < k; ++i) {
+            for (int i = 0; i < k; i++) {
                 checkIncomplete(f);
                 checkIncomplete(CompletableFuture.allOf(fs));
                 fs[i].complete(one);
@@ -2939,10 +2939,10 @@ public class CompletableFutureTest exten
     }
 
     public void testAllOf_backwards() throws Exception {
-        for (int k = 1; k < 20; ++k) {
+        for (int k = 1; k < 10; k++) {
             CompletableFuture<Integer>[] fs
                 = (CompletableFuture<Integer>[]) new CompletableFuture[k];
-            for (int i = 0; i < k; ++i)
+            for (int i = 0; i < k; i++)
                 fs[i] = new CompletableFuture<>();
             CompletableFuture<Void> f = CompletableFuture.allOf(fs);
             for (int i = k - 1; i >= 0; i--) {
@@ -2955,29 +2955,74 @@ public class CompletableFutureTest exten
         }
     }
 
+    public void testAllOf_exceptional() throws Exception {
+        for (int k = 1; k < 10; k++) {
+            CompletableFuture<Integer>[] fs
+                = (CompletableFuture<Integer>[]) new CompletableFuture[k];
+            CFException ex = new CFException();
+            for (int i = 0; i < k; i++)
+                fs[i] = new CompletableFuture<>();
+            CompletableFuture<Void> f = CompletableFuture.allOf(fs);
+            for (int i = 0; i < k; i++) {
+                checkIncomplete(f);
+                checkIncomplete(CompletableFuture.allOf(fs));
+                if (i != k/2) {
+                    fs[i].complete(i);
+                    checkCompletedNormally(fs[i], i);
+                } else {
+                    fs[i].completeExceptionally(ex);
+                    checkCompletedExceptionally(fs[i], ex);
+                }
+            }
+            checkCompletedWithWrappedException(f, ex);
+            checkCompletedWithWrappedException(CompletableFuture.allOf(fs), ex);
+        }
+    }
+
     /**
      * anyOf(no component futures) returns an incomplete future
      */
     public void testAnyOf_empty() throws Exception {
+        for (Integer v1 : new Integer[] { 1, null })
+    {
         CompletableFuture<Object> f = CompletableFuture.anyOf();
         checkIncomplete(f);
-    }
+
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+    }}
 
     /**
      * anyOf returns a future completed normally with a value when
      * a component future does
      */
     public void testAnyOf_normal() throws Exception {
-        for (int k = 0; k < 10; ++k) {
+        for (int k = 0; k < 10; k++) {
             CompletableFuture[] fs = new CompletableFuture[k];
-            for (int i = 0; i < k; ++i)
+            for (int i = 0; i < k; i++)
                 fs[i] = new CompletableFuture<>();
             CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
             checkIncomplete(f);
-            for (int i = 0; i < k; ++i) {
-                fs[i].complete(one);
-                checkCompletedNormally(f, one);
-                checkCompletedNormally(CompletableFuture.anyOf(fs), one);
+            for (int i = 0; i < k; i++) {
+                fs[i].complete(i);
+                checkCompletedNormally(f, 0);
+                int x = (int) CompletableFuture.anyOf(fs).join();
+                assertTrue(0 <= x && x <= i);
+            }
+        }
+    }
+    public void testAnyOf_normal_backwards() throws Exception {
+        for (int k = 0; k < 10; k++) {
+            CompletableFuture[] fs = new CompletableFuture[k];
+            for (int i = 0; i < k; i++)
+                fs[i] = new CompletableFuture<>();
+            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
+            checkIncomplete(f);
+            for (int i = k - 1; i >= 0; i--) {
+                fs[i].complete(i);
+                checkCompletedNormally(f, k - 1);
+                int x = (int) CompletableFuture.anyOf(fs).join();
+                assertTrue(i <= x && x <= k - 1);
             }
         }
     }
@@ -2986,15 +3031,36 @@ public class CompletableFutureTest exten
      * anyOf result completes exceptionally when any component does.
      */
     public void testAnyOf_exceptional() throws Exception {
-        for (int k = 0; k < 10; ++k) {
+        for (int k = 0; k < 10; k++) {
             CompletableFuture[] fs = new CompletableFuture[k];
-            for (int i = 0; i < k; ++i)
+            CFException[] exs = new CFException[k];
+            for (int i = 0; i < k; i++) {
                 fs[i] = new CompletableFuture<>();
+                exs[i] = new CFException();
+            }
             CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
             checkIncomplete(f);
-            for (int i = 0; i < k; ++i) {
-                fs[i].completeExceptionally(new CFException());
-                checkCompletedWithWrappedCFException(f);
+            for (int i = 0; i < k; i++) {
+                fs[i].completeExceptionally(exs[i]);
+                checkCompletedWithWrappedException(f, exs[0]);
+                checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
+            }
+        }
+    }
+
+    public void testAnyOf_exceptional_backwards() throws Exception {
+        for (int k = 0; k < 10; k++) {
+            CompletableFuture[] fs = new CompletableFuture[k];
+            CFException[] exs = new CFException[k];
+            for (int i = 0; i < k; i++) {
+                fs[i] = new CompletableFuture<>();
+                exs[i] = new CFException();
+            }
+            CompletableFuture<Object> f = CompletableFuture.anyOf(fs);
+            checkIncomplete(f);
+            for (int i = k - 1; i >= 0; i--) {
+                fs[i].completeExceptionally(exs[i]);
+                checkCompletedWithWrappedException(f, exs[k - 1]);
                 checkCompletedWithWrappedCFException(CompletableFuture.anyOf(fs));
             }
         }
@@ -3133,32 +3199,79 @@ public class CompletableFutureTest exten
         if (!testImplementationDetails) return;
         for (ExecutionMode m : ExecutionMode.values())
     {
-        final CompletableFuture<Void> f = new CompletableFuture<>();
-        CFException ex = new CFException();
-        f.completeExceptionally(ex);
-        final CompletableFuture<Void> g = f.thenRun(new Noop(m));
-        checkCompletedWithWrappedException(g, ex);
-        final CompletableFuture<Void> h = g.thenRun(new Noop(m));
-        checkCompletedWithWrappedException(h, ex);
-        assertSame(resultOf(g), resultOf(h));
-    }}
+        final CFException ex = new CFException();
+        final CompletableFuture<Integer> v42 = CompletableFuture.completedFuture(42);
+        final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
+
+        List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
+            = new ArrayList<>();
+
+        funs.add((y) -> m.thenRun(y, new Noop(m)));
+        funs.add((y) -> m.thenAccept(y, new NoopConsumer(m)));
+        funs.add((y) -> m.thenApply(y, new IncFunction(m)));
+
+        funs.add((y) -> m.runAfterEither(y, incomplete, new Noop(m)));
+        funs.add((y) -> m.acceptEither(y, incomplete, new NoopConsumer(m)));
+        funs.add((y) -> m.applyToEither(y, incomplete, new IncFunction(m)));
+
+        funs.add((y) -> m.runAfterBoth(y, v42, new Noop(m)));
+        funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
+        funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
+
+        funs.add((y) -> m.whenComplete(y, (Integer x, Throwable t) -> {}));
+
+        funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
+
+        funs.add((y) -> CompletableFuture.allOf(new CompletableFuture<?>[] {y, v42}));
+        funs.add((y) -> CompletableFuture.anyOf(new CompletableFuture<?>[] {y, incomplete}));
+
+        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
+                 fun : funs) {
+            CompletableFuture<Integer> f = new CompletableFuture<>();
+            f.completeExceptionally(ex);
+            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
+            checkCompletedWithWrappedException(src, ex);
+            CompletableFuture<?> dep = fun.apply(src);
+            checkCompletedWithWrappedException(dep, ex);
+            assertSame(resultOf(src), resultOf(dep));
+        }
+
+        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
+                 fun : funs) {
+            CompletableFuture<Integer> f = new CompletableFuture<>();
+            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
+            CompletableFuture<?> dep = fun.apply(src);
+            f.completeExceptionally(ex);
+            checkCompletedWithWrappedException(src, ex);
+            checkCompletedWithWrappedException(dep, ex);
+            assertSame(resultOf(src), resultOf(dep));
+        }
+
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
+                 fun : funs) {
+            CompletableFuture<Integer> f = new CompletableFuture<>();
+            f.cancel(mayInterruptIfRunning);
+            checkCancelled(f);
+            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
+            checkCompletedWithWrappedCancellationException(src);
+            CompletableFuture<?> dep = fun.apply(src);
+            checkCompletedWithWrappedCancellationException(dep);
+            assertSame(resultOf(src), resultOf(dep));
+        }
 
-//     public void testRunAfterEither_resultDeterminedAtTimeOfCreation() {
-//         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[] rs = new Noop[2];
-//         for (int i = 0; i < rs.length; i++) rs[i] = new Noop(m);
-//         f.complete(v1);
-//         final CompletableFuture<Void> h0 = m.runAfterEither(f, g, rs[0]);
-//         final CompletableFuture<Void> h1 = m.runAfterEither(g, f, rs[1]);
-//         assertTrue(g.cancel(mayInterruptIfRunning));
-//         checkCompletedNormally(h0, null);
-//         checkCompletedNormally(h1, null);
-//         for (Noop r : rs) r.assertInvoked();
-//     }}
+        for (boolean mayInterruptIfRunning : new boolean[] { true, false })
+        for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
+                 fun : funs) {
+            CompletableFuture<Integer> f = new CompletableFuture<>();
+            CompletableFuture<Integer> src = m.thenApply(f, new IncFunction(m));
+            CompletableFuture<?> dep = fun.apply(src);
+            f.cancel(mayInterruptIfRunning);
+            checkCancelled(f);
+            checkCompletedWithWrappedCancellationException(src);
+            checkCompletedWithWrappedCancellationException(dep);
+            assertSame(resultOf(src), resultOf(dep));
+        }
+    }}
 
 }