--- jsr166/src/test/tck/CompletableFutureTest.java	2015/09/10 17:51:37	1.124
+++ jsr166/src/test/tck/CompletableFutureTest.java	2015/11/15 19:55:38	1.134
@@ -7,6 +7,8 @@
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.concurrent.TimeUnit.SECONDS;
+import static java.util.concurrent.CompletableFuture.completedFuture;
+import static java.util.concurrent.CompletableFuture.failedFuture;
 
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -39,6 +41,7 @@ import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
+import junit.framework.AssertionFailedError;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
@@ -837,9 +840,9 @@ public class CompletableFutureTest exten
         if (!createIncomplete) assertTrue(f.complete(v1));
         final CompletableFuture<Integer> g = f.exceptionally
             ((Throwable t) -> {
-                // Should not be called
                 a.getAndIncrement();
-                throw new AssertionError();
+                threadFail("should not be called");
+                return null;            // unreached
             });
         if (createIncomplete) assertTrue(f.complete(v1));
 
@@ -898,7 +901,7 @@ public class CompletableFutureTest exten
      * whenComplete action executes on normal completion, propagating
      * source result.
      */
-    public void testWhenComplete_normalCompletion1() {
+    public void testWhenComplete_normalCompletion() {
         for (ExecutionMode m : ExecutionMode.values())
         for (boolean createIncomplete : new boolean[] { true, false })
         for (Integer v1 : new Integer[] { 1, null })
@@ -979,7 +982,7 @@ public class CompletableFutureTest exten
      * If a whenComplete action throws an exception when triggered by
      * a normal completion, it completes exceptionally
      */
-    public void testWhenComplete_actionFailed() {
+    public void testWhenComplete_sourceCompletedNormallyActionFailed() {
         for (boolean createIncomplete : new boolean[] { true, false })
         for (ExecutionMode m : ExecutionMode.values())
         for (Integer v1 : new Integer[] { 1, null })
@@ -1007,9 +1010,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())
     {
@@ -1122,55 +1125,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) -> {
                 m.checkExecutionMode();
-                threadAssertNull(x);
-                threadAssertSame(ex1, t);
+                threadAssertSame(x, 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());
     }}
 
-    public void testHandle_sourceCompletedNormallyActionFailed() {
-        for (ExecutionMode m : ExecutionMode.values())
+    /**
+     * If a "handle action" throws an exception when triggered by
+     * a source completion that also throws an exception, the action
+     * exception takes precedence (unlike whenComplete)
+     */
+    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) -> {
                 m.checkExecutionMode();
-                threadAssertSame(x, v1);
-                threadAssertNull(t);
+                threadAssertNull(x);
+                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());
     }}
 
@@ -3708,9 +3718,7 @@ public class CompletableFutureTest exten
             (method) -> (method.getModifiers() & Modifier.STATIC) == 0;
         List<Method> minimalMethods =
             Stream.of(Object.class, CompletionStage.class)
-            .map((klazz) -> Stream.of(klazz.getMethods()))
-            .reduce(Stream::concat)
-            .orElseGet(Stream::empty)
+            .flatMap((klazz) -> Stream.of(klazz.getMethods()))
             .filter(isNotStatic)
             .collect(Collectors.toList());
         // Methods from CompletableFuture permitted NOT to throw UOE
@@ -3762,6 +3770,148 @@ public class CompletableFutureTest exten
             throw new Error("Methods did not throw UOE: " + bugs.toString());
     }
 
+    static class Monad {
+        static class ZeroException extends RuntimeException {
+            public ZeroException() { super("monadic zero"); }
+        }
+        // "return", "unit"
+        static <T> CompletableFuture<T> unit(T value) {
+            return completedFuture(value);
+        }
+        // monadic zero ?
+        static <T> CompletableFuture<T> zero() {
+            return failedFuture(new ZeroException());
+        }
+        // >=>
+        static <T,U,V> Function<T, CompletableFuture<V>> compose
+            (Function<T, CompletableFuture<U>> f,
+             Function<U, CompletableFuture<V>> g) {
+            return (x) -> f.apply(x).thenCompose(g);
+        }
+
+        static void assertZero(CompletableFuture<?> f) {
+            try {
+                f.getNow(null);
+                throw new AssertionFailedError("should throw");
+            } catch (CompletionException success) {
+                assertTrue(success.getCause() instanceof ZeroException);
+            }
+        }
+
+        static <T> void assertFutureEquals(CompletableFuture<T> f,
+                                           CompletableFuture<T> g) {
+            T fval = null, gval = null;
+            Throwable fex = null, gex = null;
+
+            try { fval = f.get(); }
+            catch (ExecutionException ex) { fex = ex.getCause(); }
+            catch (Throwable ex) { fex = ex; }
+
+            try { gval = g.get(); }
+            catch (ExecutionException ex) { gex = ex.getCause(); }
+            catch (Throwable ex) { gex = ex; }
+
+            if (fex != null || gex != null)
+                assertSame(fex.getClass(), gex.getClass());
+            else
+                assertEquals(fval, gval);
+        }
+
+        static class PlusFuture<T> extends CompletableFuture<T> {
+            AtomicReference<Throwable> firstFailure = new AtomicReference<>(null);
+        }
+
+        // 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)
+                            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);
+                }
+            };
+            f.whenComplete(action);
+            g.whenComplete(action);
+            return plus;
+        }
+    }
+
+    /**
+     * CompletableFuture is an additive monad - sort of.
+     * https://en.wikipedia.org/wiki/Monad_(functional_programming)#Additive_monads
+     */
+    public void testAdditiveMonad() throws Throwable {
+        Function<Long, CompletableFuture<Long>> unit = Monad::unit;
+        CompletableFuture<Long> zero = Monad.zero();
+
+        // Some mutually non-commutative functions
+        Function<Long, CompletableFuture<Long>> triple
+            = (x) -> Monad.unit(3 * x);
+        Function<Long, CompletableFuture<Long>> inc
+            = (x) -> Monad.unit(x + 1);
+
+        // unit is a right identity: m >>= unit === m
+        Monad.assertFutureEquals(inc.apply(5L).thenCompose(unit),
+                                 inc.apply(5L));
+        // unit is a left identity: (unit x) >>= f === f x
+        Monad.assertFutureEquals(unit.apply(5L).thenCompose(inc),
+                                 inc.apply(5L));
+
+        // associativity: (m >>= f) >>= g === m >>= ( \x -> (f x >>= g) )
+        Monad.assertFutureEquals(
+            unit.apply(5L).thenCompose(inc).thenCompose(triple),
+            unit.apply(5L).thenCompose((x) -> inc.apply(x).thenCompose(triple)));
+
+        // The case for CompletableFuture as an additive monad is weaker...
+
+        // zero is a monadic zero
+        Monad.assertZero(zero);
+
+        // left zero: zero >>= f === zero
+        Monad.assertZero(zero.thenCompose(inc));
+        // right zero: f >>= (\x -> zero) === zero
+        Monad.assertZero(inc.apply(5L).thenCompose((x) -> zero));
+
+        // f plus zero === f
+        Monad.assertFutureEquals(Monad.unit(5L),
+                                 Monad.plus(Monad.unit(5L), zero));
+        // zero plus f === f
+        Monad.assertFutureEquals(Monad.unit(5L),
+                                 Monad.plus(zero, Monad.unit(5L)));
+        // zero plus zero === zero
+        Monad.assertZero(Monad.plus(zero, zero));
+        {
+            CompletableFuture<Long> f = Monad.plus(Monad.unit(5L),
+                                                   Monad.unit(8L));
+            // non-determinism
+            assertTrue(f.get() == 5L || f.get() == 8L);
+        }
+
+        CompletableFuture<Long> godot = new CompletableFuture<>();
+        // f plus godot === f (doesn't wait for godot)
+        Monad.assertFutureEquals(Monad.unit(5L),
+                                 Monad.plus(Monad.unit(5L), godot));
+        // godot plus f === f (doesn't wait for godot)
+        Monad.assertFutureEquals(Monad.unit(5L),
+                                 Monad.plus(godot, Monad.unit(5L)));
+    }
+
 //     static <U> U join(CompletionStage<U> stage) {
 //         CompletableFuture<U> f = new CompletableFuture<>();
 //         stage.whenComplete((v, ex) -> {