--- jsr166/src/test/tck/CompletableFutureTest.java	2015/11/15 19:55:38	1.134
+++ jsr166/src/test/tck/CompletableFutureTest.java	2015/11/15 23:31:51	1.138
@@ -876,6 +876,10 @@ public class CompletableFutureTest exten
         assertEquals(1, a.get());
     }}
 
+    /**
+     * If an "exceptionally action" throws an exception, it completes
+     * exceptionally with that exception
+     */
     public void testExceptionally_exceptionalCompletionActionFailed() {
         for (boolean createIncomplete : new boolean[] { true, false })
     {
@@ -894,6 +898,7 @@ public class CompletableFutureTest exten
         if (createIncomplete) f.completeExceptionally(ex1);
 
         checkCompletedWithWrappedException(g, ex2);
+        checkCompletedExceptionally(f, ex1);
         assertEquals(1, a.get());
     }}
 
@@ -911,9 +916,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.complete(v1));
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertSame(x, v1);
+                threadAssertSame(result, v1);
                 threadAssertNull(t);
                 a.getAndIncrement();
             });
@@ -938,9 +943,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) f.completeExceptionally(ex);
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
+                threadAssertNull(result);
                 threadAssertSame(t, ex);
                 a.getAndIncrement();
             });
@@ -965,9 +970,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
+                threadAssertNull(result);
                 threadAssertTrue(t instanceof CancellationException);
                 a.getAndIncrement();
             });
@@ -993,9 +998,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.complete(v1));
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertSame(x, v1);
+                threadAssertSame(result, v1);
                 threadAssertNull(t);
                 a.getAndIncrement();
                 throw ex;
@@ -1024,10 +1029,10 @@ public class CompletableFutureTest exten
         if (!createIncomplete) f.completeExceptionally(ex1);
         final CompletableFuture<Integer> g = m.whenComplete
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
                 threadAssertSame(t, ex1);
-                threadAssertNull(x);
+                threadAssertNull(result);
                 a.getAndIncrement();
                 throw ex2;
             });
@@ -1035,6 +1040,8 @@ public class CompletableFutureTest exten
 
         checkCompletedWithWrappedException(g, ex1);
         checkCompletedExceptionally(f, ex1);
+        assertEquals(1, ex1.getSuppressed().length);
+        assertSame(ex2, ex1.getSuppressed()[0]);
         assertEquals(1, a.get());
     }}
 
@@ -1052,9 +1059,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.complete(v1));
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertSame(x, v1);
+                threadAssertSame(result, v1);
                 threadAssertNull(t);
                 a.getAndIncrement();
                 return inc(v1);
@@ -1081,9 +1088,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) f.completeExceptionally(ex);
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
+                threadAssertNull(result);
                 threadAssertSame(t, ex);
                 a.getAndIncrement();
                 return v1;
@@ -1110,9 +1117,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
+                threadAssertNull(result);
                 threadAssertTrue(t instanceof CancellationException);
                 a.getAndIncrement();
                 return v1;
@@ -1139,9 +1146,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.complete(v1));
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertSame(x, v1);
+                threadAssertSame(result, v1);
                 threadAssertNull(t);
                 a.getAndIncrement();
                 throw ex;
@@ -1170,9 +1177,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) f.completeExceptionally(ex1);
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
+                threadAssertNull(result);
                 threadAssertSame(ex1, t);
                 a.getAndIncrement();
                 throw ex2;
@@ -3651,7 +3658,7 @@ public class CompletableFutureTest exten
         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.whenComplete(y, (Integer r, Throwable t) -> {}));
 
         funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
 
@@ -3821,29 +3828,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);