--- jsr166/src/test/tck/CompletableFutureTest.java	2015/01/15 18:34:19	1.100
+++ jsr166/src/test/tck/CompletableFutureTest.java	2015/09/06 21:14:12	1.121
@@ -21,7 +21,9 @@ import java.util.concurrent.Executor;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ForkJoinTask;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;
 import java.util.function.BiFunction;
 import java.util.function.Consumer;
@@ -34,7 +36,7 @@ import junit.framework.TestSuite;
 public class CompletableFutureTest extends JSR166TestCase {
 
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
     public static Test suite() {
         return new TestSuite(CompletableFutureTest.class);
@@ -45,7 +47,7 @@ public class CompletableFutureTest exten
     void checkIncomplete(CompletableFuture<?> f) {
         assertFalse(f.isDone());
         assertFalse(f.isCancelled());
-        assertTrue(f.toString().contains("[Not completed]"));
+        assertTrue(f.toString().contains("Not completed"));
         try {
             assertNull(f.getNow(null));
         } catch (Throwable fail) { threadUnexpectedException(fail); }
@@ -75,105 +77,94 @@ public class CompletableFutureTest exten
         assertTrue(f.toString().contains("[Completed normally]"));
     }
 
-    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
+    /**
+     * Returns the "raw" internal exceptional completion of f,
+     * without any additional wrapping with CompletionException.
+     */
+    <U> Throwable exceptionalCompletion(CompletableFuture<U> f) {
+        // handle (and whenComplete) can distinguish between "direct"
+        // and "wrapped" exceptional completion
+        return f.handle((U u, Throwable t) -> t).join();
+    }
+
+    void checkCompletedExceptionally(CompletableFuture<?> f,
+                                     boolean wrapped,
+                                     Consumer<Throwable> checker) {
+        Throwable cause = exceptionalCompletion(f);
+        if (wrapped) {
+            assertTrue(cause instanceof CompletionException);
+            cause = cause.getCause();
+        }
+        checker.accept(cause);
+
         long startTime = System.nanoTime();
-        long timeoutMillis = LONG_DELAY_MS;
         try {
-            f.get(timeoutMillis, MILLISECONDS);
+            f.get(LONG_DELAY_MS, MILLISECONDS);
             shouldThrow();
         } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof CFException);
+            assertSame(cause, success.getCause());
         } catch (Throwable fail) { threadUnexpectedException(fail); }
-        assertTrue(millisElapsedSince(startTime) < timeoutMillis/2);
+        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
 
         try {
             f.join();
             shouldThrow();
         } catch (CompletionException success) {
-            assertTrue(success.getCause() instanceof CFException);
-        }
+            assertSame(cause, success.getCause());
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
+
         try {
             f.getNow(null);
             shouldThrow();
         } catch (CompletionException success) {
-            assertTrue(success.getCause() instanceof CFException);
-        }
+            assertSame(cause, success.getCause());
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
+
         try {
             f.get();
             shouldThrow();
         } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof CFException);
+            assertSame(cause, success.getCause());
         } catch (Throwable fail) { threadUnexpectedException(fail); }
-        assertTrue(f.isDone());
+
         assertFalse(f.isCancelled());
+        assertTrue(f.isDone());
+        assertTrue(f.isCompletedExceptionally());
         assertTrue(f.toString().contains("[Completed exceptionally]"));
     }
 
-    <U> void checkCompletedExceptionallyWithRootCause(CompletableFuture<U> f,
-                                                      Throwable ex) {
-        long startTime = System.nanoTime();
-        long timeoutMillis = LONG_DELAY_MS;
-        try {
-            f.get(timeoutMillis, MILLISECONDS);
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertSame(ex, success.getCause());
-        } catch (Throwable fail) { threadUnexpectedException(fail); }
-        assertTrue(millisElapsedSince(startTime) < timeoutMillis/2);
+    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
+        checkCompletedExceptionally(f, true,
+            (t) -> assertTrue(t instanceof CFException));
+    }
 
-        try {
-            f.join();
-            shouldThrow();
-        } catch (CompletionException success) {
-            assertSame(ex, success.getCause());
-        }
-        try {
-            f.getNow(null);
-            shouldThrow();
-        } catch (CompletionException success) {
-            assertSame(ex, success.getCause());
-        }
-        try {
-            f.get();
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertSame(ex, success.getCause());
-        } catch (Throwable fail) { threadUnexpectedException(fail); }
+    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
+        checkCompletedExceptionally(f, true,
+            (t) -> assertTrue(t instanceof CancellationException));
+    }
 
-        assertTrue(f.isDone());
-        assertFalse(f.isCancelled());
-        assertTrue(f.toString().contains("[Completed exceptionally]"));
+    void checkCompletedWithTimeoutException(CompletableFuture<?> f) {
+        checkCompletedExceptionally(f, false,
+            (t) -> assertTrue(t instanceof TimeoutException));
     }
 
-    <U> void checkCompletedWithWrappedException(CompletableFuture<U> f,
-                                                Throwable ex) {
-        checkCompletedExceptionallyWithRootCause(f, ex);
-        try {
-            CompletableFuture<Throwable> spy = f.handle
-                ((U u, Throwable t) -> t);
-            assertTrue(spy.join() instanceof CompletionException);
-            assertSame(ex, spy.join().getCause());
-        } catch (Throwable fail) { threadUnexpectedException(fail); }
+    void checkCompletedWithWrappedException(CompletableFuture<?> f,
+                                            Throwable ex) {
+        checkCompletedExceptionally(f, true, (t) -> assertSame(t, ex));
     }
 
-    <U> void checkCompletedExceptionally(CompletableFuture<U> f, Throwable ex) {
-        checkCompletedExceptionallyWithRootCause(f, ex);
-        try {
-            CompletableFuture<Throwable> spy = f.handle
-                ((U u, Throwable t) -> t);
-            assertSame(ex, spy.join());
-        } catch (Throwable fail) { threadUnexpectedException(fail); }
+    void checkCompletedExceptionally(CompletableFuture<?> f, Throwable ex) {
+        checkCompletedExceptionally(f, false, (t) -> assertSame(t, ex));
     }
 
     void checkCancelled(CompletableFuture<?> f) {
         long startTime = System.nanoTime();
-        long timeoutMillis = LONG_DELAY_MS;
         try {
-            f.get(timeoutMillis, MILLISECONDS);
+            f.get(LONG_DELAY_MS, MILLISECONDS);
             shouldThrow();
         } catch (CancellationException success) {
         } catch (Throwable fail) { threadUnexpectedException(fail); }
-        assertTrue(millisElapsedSince(startTime) < timeoutMillis/2);
+        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
 
         try {
             f.join();
@@ -188,44 +179,12 @@ public class CompletableFutureTest exten
             shouldThrow();
         } catch (CancellationException success) {
         } catch (Throwable fail) { threadUnexpectedException(fail); }
-        assertTrue(f.isDone());
-        assertTrue(f.isCompletedExceptionally());
-        assertTrue(f.isCancelled());
-        assertTrue(f.toString().contains("[Completed exceptionally]"));
-    }
 
-    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
-        long startTime = System.nanoTime();
-        long timeoutMillis = LONG_DELAY_MS;
-        try {
-            f.get(timeoutMillis, MILLISECONDS);
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof CancellationException);
-        } catch (Throwable fail) { threadUnexpectedException(fail); }
-        assertTrue(millisElapsedSince(startTime) < timeoutMillis/2);
+        assertTrue(exceptionalCompletion(f) instanceof CancellationException);
 
-        try {
-            f.join();
-            shouldThrow();
-        } catch (CompletionException success) {
-            assertTrue(success.getCause() instanceof CancellationException);
-        }
-        try {
-            f.getNow(null);
-            shouldThrow();
-        } catch (CompletionException success) {
-            assertTrue(success.getCause() instanceof CancellationException);
-        }
-        try {
-            f.get();
-            shouldThrow();
-        } catch (ExecutionException success) {
-            assertTrue(success.getCause() instanceof CancellationException);
-        } catch (Throwable fail) { threadUnexpectedException(fail); }
         assertTrue(f.isDone());
-        assertFalse(f.isCancelled());
         assertTrue(f.isCompletedExceptionally());
+        assertTrue(f.isCancelled());
         assertTrue(f.toString().contains("[Completed exceptionally]"));
     }
 
@@ -273,8 +232,9 @@ public class CompletableFutureTest exten
     {
         CompletableFuture<Integer> f = new CompletableFuture<>();
         checkIncomplete(f);
-        assertTrue(f.cancel(true));
-        assertTrue(f.cancel(true));
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        assertTrue(f.cancel(mayInterruptIfRunning));
+        assertTrue(f.cancel(!mayInterruptIfRunning));
         checkCancelled(f);
     }}
 
@@ -906,7 +866,6 @@ public class CompletableFutureTest exten
 
     public void testExceptionally_exceptionalCompletionActionFailed() {
         for (boolean createIncomplete : new boolean[] { true, false })
-        for (Integer v1 : new Integer[] { 1, null })
     {
         final AtomicInteger a = new AtomicInteger(0);
         final CFException ex1 = new CFException();
@@ -960,7 +919,6 @@ public class CompletableFutureTest exten
     public void testWhenComplete_exceptionalCompletion() {
         for (ExecutionMode m : ExecutionMode.values())
         for (boolean createIncomplete : new boolean[] { true, false })
-        for (Integer v1 : new Integer[] { 1, null })
     {
         final AtomicInteger a = new AtomicInteger(0);
         final CFException ex = new CFException();
@@ -1045,7 +1003,6 @@ public class CompletableFutureTest exten
     public void testWhenComplete_actionFailedSourceFailed() {
         for (boolean createIncomplete : new boolean[] { true, false })
         for (ExecutionMode m : ExecutionMode.values())
-        for (Integer v1 : new Integer[] { 1, null })
     {
         final AtomicInteger a = new AtomicInteger(0);
         final CFException ex1 = new CFException();
@@ -3105,7 +3062,7 @@ public class CompletableFutureTest exten
             for (int i = 0; i < k; i++) {
                 checkIncomplete(f);
                 checkIncomplete(CompletableFuture.allOf(fs));
-                if (i != k/2) {
+                if (i != k / 2) {
                     fs[i].complete(i);
                     checkCompletedNormally(fs[i], i);
                 } else {
@@ -3212,7 +3169,6 @@ public class CompletableFutureTest exten
         CompletableFuture<Integer> f = new CompletableFuture<>();
         CompletableFuture<Integer> g = new CompletableFuture<>();
         CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
-        CompletableFuture<?> h;
         ThreadExecutor exec = new ThreadExecutor();
 
         Runnable[] throwingActions = {
@@ -3309,6 +3265,16 @@ public class CompletableFutureTest exten
             () -> CompletableFuture.anyOf(null, f),
 
             () -> f.obtrudeException(null),
+
+            () -> CompletableFuture.delayedExecutor(1L, SECONDS, null),
+            () -> CompletableFuture.delayedExecutor(1L, null, new ThreadExecutor()),
+            () -> CompletableFuture.delayedExecutor(1L, null),
+
+            () -> f.orTimeout(1L, null),
+            () -> f.completeOnTimeout(42, 1L, null),
+
+            () -> CompletableFuture.failedFuture(null),
+            () -> CompletableFuture.failedStage(null),
         };
 
         assertThrows(NullPointerException.class, throwingActions);
@@ -3323,6 +3289,318 @@ public class CompletableFutureTest exten
         assertSame(f, f.toCompletableFuture());
     }
 
+    // jdk9
+
+    /**
+     * newIncompleteFuture returns an incomplete CompletableFuture
+     */
+    public void testNewIncompleteFuture() {
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletableFuture<Integer> g = f.newIncompleteFuture();
+        checkIncomplete(f);
+        checkIncomplete(g);
+        f.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkIncomplete(g);
+        g.complete(v1);
+        checkCompletedNormally(g, v1);
+        assertSame(g.getClass(), CompletableFuture.class);
+    }}
+
+    /**
+     * completedStage returns a completed CompletionStage
+     */
+    public void testCompletedStage() {
+        AtomicInteger x = new AtomicInteger(0);
+        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
+        CompletionStage<Integer> f = CompletableFuture.completedStage(1);
+        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
+        assertEquals(x.get(), 1);
+        assertNull(r.get());
+    }
+
+    /**
+     * defaultExecutor by default returns the commonPool if
+     * it supports more than one thread.
+     */
+    public void testDefaultExecutor() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        Executor e = f.defaultExecutor();
+        Executor c = ForkJoinPool.commonPool();
+        if (ForkJoinPool.getCommonPoolParallelism() > 1)
+            assertSame(e, c);
+        else
+            assertNotSame(e, c);
+    }
+
+    /**
+     * failedFuture returns a CompletableFuture completed
+     * exceptionally with the given Exception
+     */
+    public void testFailedFuture() {
+        CFException ex = new CFException();
+        CompletableFuture<Integer> f = CompletableFuture.failedFuture(ex);
+        checkCompletedExceptionally(f, ex);
+    }
+
+    /**
+     * failedFuture(null) throws NPE
+     */
+    public void testFailedFuture_null() {
+        try {
+            CompletableFuture<Integer> f = CompletableFuture.failedFuture(null);
+            shouldThrow();
+        } catch (NullPointerException success) {}
+    }
+
+    /**
+     * copy returns a CompletableFuture that is completed normally,
+     * with the same value, when source is.
+     */
+    public void testCopy() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletableFuture<Integer> g = f.copy();
+        checkIncomplete(f);
+        checkIncomplete(g);
+        f.complete(1);
+        checkCompletedNormally(f, 1);
+        checkCompletedNormally(g, 1);
+    }
+
+    /**
+     * copy returns a CompletableFuture that is completed exceptionally
+     * when source is.
+     */
+    public void testCopy2() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletableFuture<Integer> g = f.copy();
+        checkIncomplete(f);
+        checkIncomplete(g);
+        CFException ex = new CFException();
+        f.completeExceptionally(ex);
+        checkCompletedExceptionally(f, ex);
+        checkCompletedWithWrappedException(g, ex);
+    }
+
+    /**
+     * minimalCompletionStage returns a CompletableFuture that is
+     * completed normally, with the same value, when source is.
+     */
+    public void testMinimalCompletionStage() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletionStage<Integer> g = f.minimalCompletionStage();
+        AtomicInteger x = new AtomicInteger(0);
+        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
+        checkIncomplete(f);
+        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
+        f.complete(1);
+        checkCompletedNormally(f, 1);
+        assertEquals(x.get(), 1);
+        assertNull(r.get());
+    }
+
+    /**
+     * minimalCompletionStage returns a CompletableFuture that is
+     * completed exceptionally when source is.
+     */
+    public void testMinimalCompletionStage2() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletionStage<Integer> g = f.minimalCompletionStage();
+        AtomicInteger x = new AtomicInteger(0);
+        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
+        g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
+        checkIncomplete(f);
+        CFException ex = new CFException();
+        f.completeExceptionally(ex);
+        checkCompletedExceptionally(f, ex);
+        assertEquals(x.get(), 0);
+        assertEquals(r.get().getCause(), ex);
+    }
+
+    /**
+     * failedStage returns a CompletionStage completed
+     * exceptionally with the given Exception
+     */
+    public void testFailedStage() {
+        CFException ex = new CFException();
+        CompletionStage<Integer> f = CompletableFuture.failedStage(ex);
+        AtomicInteger x = new AtomicInteger(0);
+        AtomicReference<Throwable> r = new AtomicReference<Throwable>();
+        f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
+        assertEquals(x.get(), 0);
+        assertEquals(r.get(), ex);
+    }
+
+    /**
+     * completeAsync completes with value of given supplier
+     */
+    public void testCompleteAsync() {
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        f.completeAsync(() -> v1);
+        f.join();
+        checkCompletedNormally(f, v1);
+    }}
+
+    /**
+     * completeAsync completes exceptionally if given supplier throws
+     */
+    public void testCompleteAsync2() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CFException ex = new CFException();
+        f.completeAsync(() -> {if (true) throw ex; return 1;});
+        try {
+            f.join();
+            shouldThrow();
+        } catch (CompletionException success) {}
+        checkCompletedWithWrappedException(f, ex);
+    }
+
+    /**
+     * completeAsync with given executor completes with value of given supplier
+     */
+    public void testCompleteAsync3() {
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        ThreadExecutor executor = new ThreadExecutor();
+        f.completeAsync(() -> v1, executor);
+        assertSame(v1, f.join());
+        checkCompletedNormally(f, v1);
+        assertEquals(1, executor.count.get());
+    }}
+
+    /**
+     * completeAsync with given executor completes exceptionally if
+     * given supplier throws
+     */
+    public void testCompleteAsync4() {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CFException ex = new CFException();
+        ThreadExecutor executor = new ThreadExecutor();
+        f.completeAsync(() -> {if (true) throw ex; return 1;}, executor);
+        try {
+            f.join();
+            shouldThrow();
+        } catch (CompletionException success) {}
+        checkCompletedWithWrappedException(f, ex);
+        assertEquals(1, executor.count.get());
+    }
+
+    /**
+     * orTimeout completes with TimeoutException if not complete
+     */
+    public void testOrTimeout_timesOut() {
+        long timeoutMillis = timeoutMillis();
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        long startTime = System.nanoTime();
+        f.orTimeout(timeoutMillis, MILLISECONDS);
+        checkCompletedWithTimeoutException(f);
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
+    }
+
+    /**
+     * orTimeout completes normally if completed before timeout
+     */
+    public void testOrTimeout_completed() {
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletableFuture<Integer> g = new CompletableFuture<>();
+        long startTime = System.nanoTime();
+        f.complete(v1);
+        f.orTimeout(LONG_DELAY_MS, MILLISECONDS);
+        g.orTimeout(LONG_DELAY_MS, MILLISECONDS);
+        g.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v1);
+        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
+    }}
+
+    /**
+     * completeOnTimeout completes with given value if not complete
+     */
+    public void testCompleteOnTimeout_timesOut() {
+        testInParallel(() -> testCompleteOnTimeout_timesOut(42),
+                       () -> testCompleteOnTimeout_timesOut(null));
+    }
+
+    public void testCompleteOnTimeout_timesOut(Integer v) {
+        long timeoutMillis = timeoutMillis();
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        long startTime = System.nanoTime();
+        f.completeOnTimeout(v, timeoutMillis, MILLISECONDS);
+        assertSame(v, f.join());
+        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
+        f.complete(99);         // should have no effect
+        checkCompletedNormally(f, v);
+    }
+
+    /**
+     * completeOnTimeout has no effect if completed within timeout
+     */
+    public void testCompleteOnTimeout_completed() {
+        for (Integer v1 : new Integer[] { 1, null })
+    {
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletableFuture<Integer> g = new CompletableFuture<>();
+        long startTime = System.nanoTime();
+        f.complete(v1);
+        f.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS);
+        g.completeOnTimeout(-1, LONG_DELAY_MS, MILLISECONDS);
+        g.complete(v1);
+        checkCompletedNormally(f, v1);
+        checkCompletedNormally(g, v1);
+        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);
+    }}
+
+    /**
+     * delayedExecutor returns an executor that delays submission
+     */
+    public void testDelayedExecutor() {
+        testInParallel(() -> testDelayedExecutor(null, null),
+                       () -> testDelayedExecutor(null, 1),
+                       () -> testDelayedExecutor(new ThreadExecutor(), 1),
+                       () -> testDelayedExecutor(new ThreadExecutor(), 1));
+    }
+
+    /**
+     * delayedExecutor returns an executor that delays submission
+     */
+    public void testDelayedExecutor(Executor executor, Integer v) throws Exception {
+        long timeoutMillis = timeoutMillis();
+        // Use an "unreasonably long" long timeout to catch lingering threads
+        long longTimeoutMillis = 1000 * 60 * 60 * 24;
+        final Executor delayer, longDelayer;
+        if (executor == null) {
+            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS);
+            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS);
+        } else {
+            delayer = CompletableFuture.delayedExecutor(timeoutMillis, MILLISECONDS, executor);
+            longDelayer = CompletableFuture.delayedExecutor(longTimeoutMillis, MILLISECONDS, executor);
+        }
+        long startTime = System.nanoTime();
+        CompletableFuture<Integer> f =
+            CompletableFuture.supplyAsync(() -> v, delayer);
+        CompletableFuture<Integer> g =
+            CompletableFuture.supplyAsync(() -> v, longDelayer);
+
+        assertNull(g.getNow(null));
+
+        assertSame(v, f.get(LONG_DELAY_MS, MILLISECONDS));
+        long millisElapsed = millisElapsedSince(startTime);
+        assertTrue(millisElapsed >= timeoutMillis);
+        assertTrue(millisElapsed < LONG_DELAY_MS / 2);
+
+        checkCompletedNormally(f, v);
+
+        checkIncomplete(g);
+        assertTrue(g.cancel(true));
+    }
+
     //--- tests of implementation details; not part of official tck ---
 
     Object resultOf(CompletableFuture<?> f) {