--- jsr166/src/test/tck/CompletableFutureTest.java	2015/11/15 20:17:11	1.136
+++ jsr166/src/test/tck/CompletableFutureTest.java	2016/04/01 23:18:00	1.142
@@ -640,8 +640,12 @@ public class CompletableFutureTest exten
 
         ASYNC {
             public void checkExecutionMode() {
-                assertEquals(defaultExecutorIsCommonPool,
-                             (ForkJoinPool.commonPool() == ForkJoinTask.getPool()));
+                // If tests are added that may run across different
+                // pools, this needs to be weakened to no-op.
+                ForkJoinPool p = ForkJoinTask.getPool();
+                assertTrue(p == null ||
+                           (defaultExecutorIsCommonPool &&
+                            p == ForkJoinPool.commonPool()));
             }
             public CompletableFuture<Void> runAsync(Runnable a) {
                 return CompletableFuture.runAsync(a);
@@ -1040,6 +1044,10 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedException(g, ex1);
         checkCompletedExceptionally(f, ex1);
+        if (testImplementationDetails) {
+            assertEquals(1, ex1.getSuppressed().length);
+            assertSame(ex2, ex1.getSuppressed()[0]);
+        }
         assertEquals(1, a.get());
     }}
 
@@ -3826,29 +3834,33 @@ public class CompletableFutureTest exten
             AtomicReference<Throwable> firstFailure = new AtomicReference<>(null);
         }
 
-        // Monadic "plus"
+        /** Implements "monadic plus". */
         static <T> CompletableFuture<T> plus(CompletableFuture<? extends T> f,
                                              CompletableFuture<? extends T> g) {
             PlusFuture<T> plus = new PlusFuture<T>();
             BiConsumer<T, Throwable> action = (T result, Throwable ex) -> {
-                if (ex == null) {
-                    if (plus.complete(result))
-                        if (plus.firstFailure.get() != null)
+                try {
+                    if (ex == null) {
+                        if (plus.complete(result))
+                            if (plus.firstFailure.get() != null)
+                                plus.firstFailure.set(null);
+                    }
+                    else if (plus.firstFailure.compareAndSet(null, ex)) {
+                        if (plus.isDone())
                             plus.firstFailure.set(null);
-                }
-                else if (plus.firstFailure.compareAndSet(null, ex)) {
-                    if (plus.isDone())
-                        plus.firstFailure.set(null);
-                }
-                else {
-                    // first failure has precedence
-                    Throwable first = plus.firstFailure.getAndSet(null);
-
-                    // may fail with "Self-suppression not permitted"
-                    try { first.addSuppressed(ex); }
-                    catch (Exception ignored) {}
-
-                    plus.completeExceptionally(first);
+                    }
+                    else {
+                        // first failure has precedence
+                        Throwable first = plus.firstFailure.getAndSet(null);
+
+                        // may fail with "Self-suppression not permitted"
+                        try { first.addSuppressed(ex); }
+                        catch (Exception ignored) {}
+
+                        plus.completeExceptionally(first);
+                    }
+                } catch (Throwable unexpected) {
+                    plus.completeExceptionally(unexpected);
                 }
             };
             f.whenComplete(action);
@@ -3917,6 +3929,38 @@ public class CompletableFutureTest exten
                                  Monad.plus(godot, Monad.unit(5L)));
     }
 
+    /**
+     * A single CompletableFuture with many dependents.
+     * A demo of scalability - runtime is O(n).
+     */
+    public void testManyDependents() throws Throwable {
+        final int n = 1_000;
+        final CompletableFuture<Void> head = new CompletableFuture<>();
+        final CompletableFuture<Void> complete = CompletableFuture.completedFuture((Void)null);
+        final AtomicInteger count = new AtomicInteger(0);
+        for (int i = 0; i < n; i++) {
+            head.thenRun(() -> count.getAndIncrement());
+            head.thenAccept((x) -> count.getAndIncrement());
+            head.thenApply((x) -> count.getAndIncrement());
+
+            head.runAfterBoth(complete, () -> count.getAndIncrement());
+            head.thenAcceptBoth(complete, (x, y) -> count.getAndIncrement());
+            head.thenCombine(complete, (x, y) -> count.getAndIncrement());
+            complete.runAfterBoth(head, () -> count.getAndIncrement());
+            complete.thenAcceptBoth(head, (x, y) -> count.getAndIncrement());
+            complete.thenCombine(head, (x, y) -> count.getAndIncrement());
+
+            head.runAfterEither(new CompletableFuture<Void>(), () -> count.getAndIncrement());
+            head.acceptEither(new CompletableFuture<Void>(), (x) -> count.getAndIncrement());
+            head.applyToEither(new CompletableFuture<Void>(), (x) -> count.getAndIncrement());
+            new CompletableFuture<Void>().runAfterEither(head, () -> count.getAndIncrement());
+            new CompletableFuture<Void>().acceptEither(head, (x) -> count.getAndIncrement());
+            new CompletableFuture<Void>().applyToEither(head, (x) -> count.getAndIncrement());
+        }
+        head.complete(null);
+        assertEquals(5 * 3 * n, count.get());
+    }
+
 //     static <U> U join(CompletionStage<U> stage) {
 //         CompletableFuture<U> f = new CompletableFuture<>();
 //         stage.whenComplete((v, ex) -> {