--- jsr166/src/test/tck/CompletableFutureTest.java	2015/11/15 19:39:25	1.133
+++ jsr166/src/test/tck/CompletableFutureTest.java	2015/11/15 20:17:11	1.136
@@ -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;
@@ -1010,9 +1015,9 @@ public class CompletableFutureTest exten
     /**
      * If a whenComplete action throws an exception when triggered by
      * a source completion that also throws an exception, the source
-     * exception takes precedence.
+     * exception takes precedence (unlike handle)
      */
-    public void testWhenComplete_actionFailedSourceFailed() {
+    public void testWhenComplete_sourceFailedActionFailed() {
         for (boolean createIncomplete : new boolean[] { true, false })
         for (ExecutionMode m : ExecutionMode.values())
     {
@@ -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;
             });
@@ -1052,9 +1057,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 +1086,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 +1115,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;
@@ -1125,59 +1130,62 @@ public class CompletableFutureTest exten
     }}
 
     /**
-     * handle result completes exceptionally if action does
+     * If a "handle action" throws an exception when triggered by
+     * a normal completion, it completes exceptionally
      */
-    public void testHandle_sourceFailedActionFailed() {
+    public void testHandle_sourceCompletedNormallyActionFailed() {
         for (ExecutionMode m : ExecutionMode.values())
         for (boolean createIncomplete : new boolean[] { true, false })
+        for (Integer v1 : new Integer[] { 1, null })
     {
         final CompletableFuture<Integer> f = new CompletableFuture<>();
         final AtomicInteger a = new AtomicInteger(0);
-        final CFException ex1 = new CFException();
-        final CFException ex2 = new CFException();
-        if (!createIncomplete) f.completeExceptionally(ex1);
+        final CFException ex = new CFException();
+        if (!createIncomplete) assertTrue(f.complete(v1));
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
-                threadAssertSame(ex1, t);
+                threadAssertSame(result, v1);
+                threadAssertNull(t);
                 a.getAndIncrement();
-                throw ex2;
+                throw ex;
             });
-        if (createIncomplete) f.completeExceptionally(ex1);
+        if (createIncomplete) assertTrue(f.complete(v1));
 
-        checkCompletedWithWrappedException(g, ex2);
-        checkCompletedExceptionally(f, ex1);
+        checkCompletedWithWrappedException(g, ex);
+        checkCompletedNormally(f, v1);
         assertEquals(1, a.get());
     }}
 
     /**
      * If a "handle action" throws an exception when triggered by
-     * a normal completion, it completes exceptionally
+     * a source completion that also throws an exception, the action
+     * exception takes precedence (unlike whenComplete)
      */
-    public void testHandle_sourceCompletedNormallyActionFailed() {
-        for (ExecutionMode m : ExecutionMode.values())
+    public void testHandle_sourceFailedActionFailed() {
         for (boolean createIncomplete : new boolean[] { true, false })
-        for (Integer v1 : new Integer[] { 1, null })
+        for (ExecutionMode m : ExecutionMode.values())
     {
-        final CompletableFuture<Integer> f = new CompletableFuture<>();
         final AtomicInteger a = new AtomicInteger(0);
-        final CFException ex = new CFException();
-        if (!createIncomplete) assertTrue(f.complete(v1));
+        final CFException ex1 = new CFException();
+        final CFException ex2 = new CFException();
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
+
+        if (!createIncomplete) f.completeExceptionally(ex1);
         final CompletableFuture<Integer> g = m.handle
             (f,
-             (Integer x, Throwable t) -> {
+             (Integer result, Throwable t) -> {
                 m.checkExecutionMode();
-                threadAssertSame(x, v1);
-                threadAssertNull(t);
+                threadAssertNull(result);
+                threadAssertSame(ex1, t);
                 a.getAndIncrement();
-                throw ex;
+                throw ex2;
             });
-        if (createIncomplete) assertTrue(f.complete(v1));
+        if (createIncomplete) f.completeExceptionally(ex1);
 
-        checkCompletedWithWrappedException(g, ex);
-        checkCompletedNormally(f, v1);
+        checkCompletedWithWrappedException(g, ex2);
+        checkCompletedExceptionally(f, ex1);
         assertEquals(1, a.get());
     }}
 
@@ -3648,7 +3656,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)));