[ViewVC] Diff of: jsr166/jsr166/src/test/tck/CompletableFutureTest.java

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.96 by jsr166, Sat Nov 1 14:50:26 2014 UTC vs.
Revision 1.103 by dl, Thu Sep 3 11:45:34 2015 UTC

+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
-<
+import junit.framework.*;
->
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
->
+import static java.util.concurrent.TimeUnit.SECONDS;
->
->
+import java.util.ArrayList;
->
+import java.util.List;
->
+import java.util.Objects;
+import java.util.concurrent.Callable;
-–
+import java.util.concurrent.Executor;
-–
+import java.util.concurrent.ExecutorService;
-–
+import java.util.concurrent.Executors;
+import java.util.concurrent.CancellationException;
-–
+import java.util.concurrent.CountDownLatch;
-–
+import java.util.concurrent.ExecutionException;
-–
+import java.util.concurrent.Future;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.CompletionStage;
-+
+import java.util.concurrent.ExecutionException;
-+
+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 static java.util.concurrent.TimeUnit.MILLISECONDS;
-<
+import static java.util.concurrent.TimeUnit.SECONDS;
-<
+import java.util.*;
-<
+import java.util.function.Supplier;
-<
+import java.util.function.Consumer;
->
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.BiConsumer;
-–
+import java.util.function.Function;
+import java.util.function.BiFunction;
-+
+import java.util.function.Consumer;
-+
+import java.util.function.Function;
-+
+import java.util.function.Supplier;
-+
-+
+import junit.framework.Test;
-+
+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);
+    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); }
+        assertTrue(f.toString().contains("[Completed exceptionally]"));
-+
+    <U> void checkCompletedExceptionallyWithTimeout(CompletableFuture<U> f) {
-+
+        long startTime = System.nanoTime();
-+
+        long timeoutMillis = LONG_DELAY_MS;
-+
+        try {
-+
+            f.get(timeoutMillis, MILLISECONDS);
-+
+            shouldThrow();
-+
+        } catch (ExecutionException ex) {
-+
+            assertTrue(ex.getCause() instanceof TimeoutException);
-+
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
-+
+        assertTrue(millisElapsedSince(startTime) < timeoutMillis/2);
-+
-+
+        try {
-+
+            f.join();
-+
+            shouldThrow();
-+
+        } catch (Throwable ex) {
-+
+            assertTrue(ex.getCause() instanceof TimeoutException);
-+
+        }
-+
-+
+        try {
-+
+            f.getNow(null);
-+
+            shouldThrow();
-+
+        } catch (Throwable ex) {
-+
+            assertTrue(ex.getCause() instanceof TimeoutException);
-+
+        }
-+
-+
+        try {
-+
+            f.get();
-+
+            shouldThrow();
-+
+        } catch (ExecutionException ex) {
-+
+            assertTrue(ex.getCause() instanceof TimeoutException);
-+
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
-+
-+
+        assertTrue(f.isDone());
-+
+        assertFalse(f.isCancelled());
-+
+        assertTrue(f.toString().contains("[Completed exceptionally]"));
-+
+    }
-+
+    <U> void checkCompletedWithWrappedException(CompletableFuture<U> f,
+                                                Throwable ex) {
+        checkCompletedExceptionallyWithRootCause(f, ex);
+        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);
+    }}
-–
+    class CompletableFutureInc extends CheckedIntegerAction
+        implements Function<Integer, CompletableFuture<Integer>>
+    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();
+    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();
+    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();
+        checkCancelled(f);
+    }}
-+
+    /**
-+
+     * thenCompose result completes exceptionally if the result of the action does
-+
+     */
-+
+    public void testThenCompose_actionReturnsFailingFuture() {
-+
+        for (ExecutionMode m : ExecutionMode.values())
-+
+        for (int order = 0; order < 6; order++)
-+
+        for (Integer v1 : new Integer[] { 1, null })
-+
+    {
-+
+        final CFException ex = new CFException();
-+
+        final CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        final CompletableFuture<Integer> g = new CompletableFuture<>();
-+
+        final CompletableFuture<Integer> h;
-+
+        // Test all permutations of orders
-+
+        switch (order) {
-+
+        case 0:
-+
+            assertTrue(f.complete(v1));
-+
+            assertTrue(g.completeExceptionally(ex));
-+
+            h = m.thenCompose(f, (x -> g));
-+
+            break;
-+
+        case 1:
-+
+            assertTrue(f.complete(v1));
-+
+            h = m.thenCompose(f, (x -> g));
-+
+            assertTrue(g.completeExceptionally(ex));
-+
+            break;
-+
+        case 2:
-+
+            assertTrue(g.completeExceptionally(ex));
-+
+            assertTrue(f.complete(v1));
-+
+            h = m.thenCompose(f, (x -> g));
-+
+            break;
-+
+        case 3:
-+
+            assertTrue(g.completeExceptionally(ex));
-+
+            h = m.thenCompose(f, (x -> g));
-+
+            assertTrue(f.complete(v1));
-+
+            break;
-+
+        case 4:
-+
+            h = m.thenCompose(f, (x -> g));
-+
+            assertTrue(f.complete(v1));
-+
+            assertTrue(g.completeExceptionally(ex));
-+
+            break;
-+
+        case 5:
-+
+            h = m.thenCompose(f, (x -> g));
-+
+            assertTrue(f.complete(v1));
-+
+            assertTrue(g.completeExceptionally(ex));
-+
+            break;
-+
+        default: throw new AssertionError();
-+
+        }
-+
-+
+        checkCompletedExceptionally(g, ex);
-+
+        checkCompletedWithWrappedException(h, ex);
-+
+        checkCompletedNormally(f, v1);
-+
+    }}
-+
+    // other static methods
+    /**
+        CompletableFuture<Integer> f = new CompletableFuture<>();
+        CompletableFuture<Integer> g = new CompletableFuture<>();
+        CompletableFuture<Integer> nullFuture = (CompletableFuture<Integer>)null;
-–
+        CompletableFuture<?> h;
+        ThreadExecutor exec = new ThreadExecutor();
+        Runnable[] throwingActions = {
+            () -> f.exceptionally(null),
+            () -> f.handle(null),
-–
+            () -> CompletableFuture.allOf((CompletableFuture<?>)null),
+            () -> CompletableFuture.allOf((CompletableFuture<?>[])null),
+            () -> CompletableFuture.allOf(f, null),
+        assertSame(f, f.toCompletableFuture());
-+
+    // jdk9
-+
-+
+    /**
-+
+     * newIncompleteFuture returns an incomplete CompletableFuture
-+
+     */
-+
+    public void testNewIncompleteFuture() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        CompletableFuture<Integer> g = f.newIncompleteFuture();
-+
+        checkIncomplete(f);
-+
+        checkIncomplete(g);
-+
+    }
-+
-+
+    /**
-+
+     * completedStage returns a completed CompletionStage
-+
+     */
-+
+    public void testCompletedStage() {
-+
+        AtomicInteger x = new AtomicInteger();
-+
+        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 at least one thread.
-+
+     */
-+
+    public void testDefaultExecutor() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        Executor e = f.defaultExecutor();
-+
+        Executor c =  ForkJoinPool.commonPool();
-+
+        if (ForkJoinPool.getCommonPoolParallelism() > 0)
-+
+            assertSame(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);
-+
+        checkCompletedExceptionallyWithRootCause(f, ex);
-+
+    }
-+
-+
+    /**
-+
+     * failedFuture(null) throws NPE
-+
+     */
-+
+    public void testFailedFuture2() {
-+
+        try {
-+
+            CompletableFuture<Integer> f = CompletableFuture.failedFuture(null);
-+
+        } 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);
-+
+        checkCompletedWithWrappedCFException(g);
-+
+    }
-+
-+
+    /**
-+
+     * 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();
-+
+        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();
-+
+        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();
-+
+        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().getCause(), ex);
-+
+    }
-+
-+
+    /**
-+
+     * completeAsync completes with value of given supplier
-+
+     */
-+
+    public void testCompleteAsync() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        f.completeAsync(() -> 1);
-+
+        f.join();
-+
+        checkCompletedNormally(f, 1);
-+
+    }
-+
-+
+    /**
-+
+     * 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(Exception success) {
-+
+        }
-+
+        checkCompletedWithWrappedCFException(f);
-+
+    }
-+
-+
+    /**
-+
+     * completeAsync with given executor completes with value of given supplier
-+
+     */
-+
+    public void testCompleteAsync3() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        f.completeAsync(() -> 1, new ThreadExecutor());
-+
+        f.join();
-+
+        checkCompletedNormally(f, 1);
-+
+    }
-+
-+
+    /**
-+
+     * completeAsync with given executor completes exceptionally if
-+
+     * given supplier throws
-+
+     */
-+
+    public void testCompleteAsync4() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        CFException ex = new CFException();
-+
+        f.completeAsync(() -> {if (true) throw ex; return 1;}, new ThreadExecutor());
-+
+        try {
-+
+            f.join();
-+
+            shouldThrow();
-+
+        } catch(Exception success) {
-+
+        }
-+
+        checkCompletedWithWrappedCFException(f);
-+
+    }
-+
-+
+    /**
-+
+     *  orTimeout completes with TimeoutException if not complete
-+
+     */
-+
+    public void testOrTimeout() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        f.orTimeout(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-+
+        checkCompletedExceptionallyWithTimeout(f);
-+
+    }
-+
-+
+    /**
-+
+     *  orTimeout completes normally if completed before timeout
-+
+     */
-+
+    public void testOrTimeout2() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        f.complete(1);
-+
+        f.orTimeout(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-+
+        checkCompletedNormally(f, 1);
-+
+    }
-+
-+
+    /**
-+
+     *  completeOnTimeout completes with given value if not complete
-+
+     */
-+
+    public void testCompleteOnTimeout() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        f.completeOnTimeout(-1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-+
+        f.join();
-+
+        checkCompletedNormally(f, -1);
-+
+    }
-+
-+
+    /**
-+
+     *  completeOnTimeout has no effect if completed within timeout
-+
+     */
-+
+    public void testCompleteOnTimeout2() {
-+
+        CompletableFuture<Integer> f = new CompletableFuture<>();
-+
+        f.complete(1);
-+
+        f.completeOnTimeout(-1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
-+
+        checkCompletedNormally(f, 1);
-+
+    }
-+
-+
+    /**
-+
+     * delayedExecutor returns an executor that delays submission
-+
+     */
-+
+    public void testDelayedExecutor() {
-+
+        long timeoutMillis = SMALL_DELAY_MS;
-+
+        Executor d = CompletableFuture.delayedExecutor(timeoutMillis,
-+
+                                                       MILLISECONDS);
-+
+        long startTime = System.nanoTime();
-+
+        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(() -> 1, d);
-+
+        assertNull(f.getNow(null));
-+
+        try {
-+
+            f.get(LONG_DELAY_MS, MILLISECONDS);
-+
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
-+
+        assertTrue(millisElapsedSince(startTime) > timeoutMillis/2);
-+
+        checkCompletedNormally(f, 1);
-+
+    }
-+
-+
+    /**
-+
+     * delayedExecutor for a given executor returns an executor that
-+
+     * delays submission
-+
+     */
-+
+    public void testDelayedExecutor2() {
-+
+        long timeoutMillis = SMALL_DELAY_MS;
-+
+        Executor d = CompletableFuture.delayedExecutor(timeoutMillis,
-+
+                                                       MILLISECONDS,
-+
+                                                       new ThreadExecutor());
-+
+        long startTime = System.nanoTime();
-+
+        CompletableFuture<Integer> f = CompletableFuture.supplyAsync(() -> 1, d);
-+
+        assertNull(f.getNow(null));
-+
+        try {
-+
+            f.get(LONG_DELAY_MS, MILLISECONDS);
-+
+        } catch (Throwable fail) { threadUnexpectedException(fail); }
-+
+        assertTrue(millisElapsedSince(startTime) > timeoutMillis/2);
-+
+        checkCompletedNormally(f, 1);
-+
+    }
-+
+    //--- tests of implementation details; not part of official tck ---
+    Object resultOf(CompletableFuture<?> f) {

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents): Revision 1.96 by jsr166, Sat Nov 1 14:50:26 2014 UTC vs. Revision 1.103 by dl, Thu Sep 3 11:45:34 2015 UTC

Diff Legend

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.96 by jsr166, Sat Nov 1 14:50:26 2014 UTC vs.
Revision 1.103 by dl, Thu Sep 3 11:45:34 2015 UTC