/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea and Martin Buchholz with assistance from

 * members of JCP JSR-166 Expert Group and released to the public

 * domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */

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;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import java.util.concurrent.Callable;

import java.util.concurrent.CancellationException;

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.RejectedExecutionException;

import java.util.concurrent.TimeoutException;

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;

import java.util.function.Function;

import java.util.function.Predicate;

import java.util.function.Supplier;

import junit.framework.Test;

import junit.framework.TestSuite;

public class CompletableFutureTest extends JSR166TestCase {

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        return new TestSuite(CompletableFutureTest.class);

    }

    static class CFException extends RuntimeException {}

    void checkIncomplete(CompletableFuture<?> f) {

        assertFalse(f.isDone());

        assertFalse(f.isCancelled());

        assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));

        Object result = null;

        try {

            result = f.getNow(null);

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertNull(result);

        try {

            f.get(randomExpiredTimeout(), randomTimeUnit());

            shouldThrow();

        }

        catch (TimeoutException success) {}

        catch (Throwable fail) { threadUnexpectedException(fail); }

    }

    <T> void checkCompletedNormally(CompletableFuture<T> f, T expectedValue) {

        checkTimedGet(f, expectedValue);

        assertEquals(expectedValue, f.join());

        assertEquals(expectedValue, f.getNow(null));

        T result = null;

        try {

            result = f.get();

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertEquals(expectedValue, result);

        assertTrue(f.isDone());

        assertFalse(f.isCancelled());

        assertFalse(f.isCompletedExceptionally());

        assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));

    }

    /**

     * Returns the "raw" internal exceptional completion of f,

     * without any additional wrapping with CompletionException.

     */

    Throwable exceptionalCompletion(CompletableFuture<?> f) {

        // handle (and whenComplete and exceptionally) can distinguish

        // between "direct" and "wrapped" exceptional completion

        return f.handle((u, 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();

        try {

            f.get(LONG_DELAY_MS, MILLISECONDS);

            shouldThrow();

        } catch (ExecutionException success) {

            assertSame(cause, success.getCause());

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);

        try {

            f.join();

            shouldThrow();

        } catch (CompletionException success) {

            assertSame(cause, success.getCause());

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {

            f.getNow(null);

            shouldThrow();

        } catch (CompletionException success) {

            assertSame(cause, success.getCause());

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {

            f.get();

            shouldThrow();

        } catch (ExecutionException success) {

            assertSame(cause, success.getCause());

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertFalse(f.isCancelled());

        assertTrue(f.isDone());

        assertTrue(f.isCompletedExceptionally());

        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));

    }

    void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {

        checkCompletedExceptionally(f, true,

            t -> assertTrue(t instanceof CFException));

    }

    void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {

        checkCompletedExceptionally(f, true,

            t -> assertTrue(t instanceof CancellationException));

    }

    void checkCompletedWithTimeoutException(CompletableFuture<?> f) {

        checkCompletedExceptionally(f, false,

            t -> assertTrue(t instanceof TimeoutException));

    }

    void checkCompletedWithWrappedException(CompletableFuture<?> f,

                                            Throwable ex) {

        checkCompletedExceptionally(f, true, t -> assertSame(t, ex));

    }

    void checkCompletedExceptionally(CompletableFuture<?> f, Throwable ex) {

        checkCompletedExceptionally(f, false, t -> assertSame(t, ex));

    }

    void checkCancelled(CompletableFuture<?> f) {

        long startTime = System.nanoTime();

        try {

            f.get(LONG_DELAY_MS, MILLISECONDS);

            shouldThrow();

        } catch (CancellationException success) {

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS / 2);

        try {

            f.join();

            shouldThrow();

        } catch (CancellationException success) {}

        try {

            f.getNow(null);

            shouldThrow();

        } catch (CancellationException success) {}

        try {

            f.get();

            shouldThrow();

        } catch (CancellationException success) {

        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertTrue(exceptionalCompletion(f) instanceof CancellationException);

        assertTrue(f.isDone());

        assertTrue(f.isCompletedExceptionally());

        assertTrue(f.isCancelled());

        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));

    }

    /**

     * A newly constructed CompletableFuture is incomplete, as indicated

     * by methods isDone, isCancelled, and getNow

     */

    public void testConstructor() {

        CompletableFuture<Integer> f = new CompletableFuture<>();

        checkIncomplete(f);

    }

    /**

     * complete completes normally, as indicated by methods isDone,

     * isCancelled, join, get, and getNow

     */

    public void testComplete() {

        for (Integer v1 : new Integer[] { 1, null })

    {

        CompletableFuture<Integer> f = new CompletableFuture<>();

        checkIncomplete(f);

        assertTrue(f.complete(v1));

        assertFalse(f.complete(v1));

        checkCompletedNormally(f, v1);

    }}

    /**

     * completeExceptionally completes exceptionally, as indicated by

     * methods isDone, isCancelled, join, get, and getNow

     */

    public void testCompleteExceptionally() {

        CompletableFuture<Integer> f = new CompletableFuture<>();

        CFException ex = new CFException();

        checkIncomplete(f);

        f.completeExceptionally(ex);

        checkCompletedExceptionally(f, ex);

    }

    /**

     * cancel completes exceptionally and reports cancelled, as indicated by

     * methods isDone, isCancelled, join, get, and getNow

     */

    public void testCancel() {

        for (boolean mayInterruptIfRunning : new boolean[] { true, false })

    {

        CompletableFuture<Integer> f = new CompletableFuture<>();

        checkIncomplete(f);

        assertTrue(f.cancel(mayInterruptIfRunning));

        assertTrue(f.cancel(mayInterruptIfRunning));

        assertTrue(f.cancel(!mayInterruptIfRunning));

        checkCancelled(f);

    }}

    /**

     * obtrudeValue forces completion with given value

     */

    public void testObtrudeValue() {

        CompletableFuture<Integer> f = new CompletableFuture<>();

        checkIncomplete(f);

        assertTrue(f.complete(one));

        checkCompletedNormally(f, one);

        f.obtrudeValue(three);

        checkCompletedNormally(f, three);

        f.obtrudeValue(two);

        checkCompletedNormally(f, two);

        f = new CompletableFuture<>();

        f.obtrudeValue(three);

        checkCompletedNormally(f, three);

        f.obtrudeValue(null);

        checkCompletedNormally(f, null);

        f = new CompletableFuture<>();

        f.completeExceptionally(new CFException());

        f.obtrudeValue(four);

        checkCompletedNormally(f, four);

    }

    /**

     * obtrudeException forces completion with given exception

     */

    public void testObtrudeException() {

        for (Integer v1 : new Integer[] { 1, null })

    {

        CFException ex;

        CompletableFuture<Integer> f;

        f = new CompletableFuture<>();

        assertTrue(f.complete(v1));

        for (int i = 0; i < 2; i++) {

            f.obtrudeException(ex = new CFException());

            checkCompletedExceptionally(f, ex);

        }

        f = new CompletableFuture<>();

        for (int i = 0; i < 2; i++) {

            f.obtrudeException(ex = new CFException());

            checkCompletedExceptionally(f, ex);

        }

        f = new CompletableFuture<>();

        f.completeExceptionally(new CFException());

        f.obtrudeValue(v1);

        checkCompletedNormally(f, v1);

        f.obtrudeException(ex = new CFException());

        checkCompletedExceptionally(f, ex);

        f.completeExceptionally(new CFException());

        checkCompletedExceptionally(f, ex);

        assertFalse(f.complete(v1));

        checkCompletedExceptionally(f, ex);

    }}

    /**

     * getNumberOfDependents returns number of dependent tasks

     */

    public void testGetNumberOfDependents() {

        for (ExecutionMode m : ExecutionMode.values())

        for (Integer v1 : new Integer[] { 1, null })

    {

        CompletableFuture<Integer> f = new CompletableFuture<>();

        assertEquals(0, f.getNumberOfDependents());

        final CompletableFuture<Void> g = m.thenRun(f, new Noop(m));

        assertEquals(1, f.getNumberOfDependents());

        assertEquals(0, g.getNumberOfDependents());

        final CompletableFuture<Void> h = m.thenRun(f, new Noop(m));

        assertEquals(2, f.getNumberOfDependents());

        assertEquals(0, h.getNumberOfDependents());

        assertTrue(f.complete(v1));

        checkCompletedNormally(g, null);

        checkCompletedNormally(h, null);

        assertEquals(0, f.getNumberOfDependents());

        assertEquals(0, g.getNumberOfDependents());

        assertEquals(0, h.getNumberOfDependents());

    }}

    /**

     * toString indicates current completion state

     */

    public void testToString_incomplete() {

        CompletableFuture<String> f = new CompletableFuture<>();

        assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));

        if (testImplementationDetails)

            assertEquals(identityString(f) + "[Not completed]",

                         f.toString());

    }

    public void testToString_normal() {

        CompletableFuture<String> f = new CompletableFuture<>();

        assertTrue(f.complete("foo"));

        assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));

        if (testImplementationDetails)

            assertEquals(identityString(f) + "[Completed normally]",

                         f.toString());

    }

    public void testToString_exception() {

        CompletableFuture<String> f = new CompletableFuture<>();

        assertTrue(f.completeExceptionally(new IndexOutOfBoundsException()));

        assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));

        if (testImplementationDetails)

            assertTrue(f.toString().startsWith(

                               identityString(f) + "[Completed exceptionally: "));

    }

    public void testToString_cancelled() {

        for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {

            CompletableFuture<String> f = new CompletableFuture<>();

            assertTrue(f.cancel(mayInterruptIfRunning));

            assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));

            if (testImplementationDetails)

                assertTrue(f.toString().startsWith(

                                   identityString(f) + "[Completed exceptionally: "));

        }

    }

    /**

     * completedFuture returns a completed CompletableFuture with given value

     */

    public void testCompletedFuture() {

        CompletableFuture<String> f = CompletableFuture.completedFuture("test");

        checkCompletedNormally(f, "test");

    }

    abstract static class CheckedAction {

        int invocationCount = 0;

        final ExecutionMode m;

        CheckedAction(ExecutionMode m) { this.m = m; }

        void invoked() {

            m.checkExecutionMode();

            assertEquals(0, invocationCount++);

        }

        void assertNotInvoked() { assertEquals(0, invocationCount); }

        void assertInvoked() { assertEquals(1, invocationCount); }

    }

    abstract static class CheckedIntegerAction extends CheckedAction {

        Integer value;

        CheckedIntegerAction(ExecutionMode m) { super(m); }

        void assertValue(Integer expected) {

            assertInvoked();

            assertEquals(expected, value);

        }

    }

    static class IntegerSupplier extends CheckedAction

        implements Supplier<Integer>

    {

        final Integer value;

        IntegerSupplier(ExecutionMode m, Integer value) {

            super(m);

            this.value = value;

        }

        public Integer get() {

            invoked();

            return value;

        }

    }

    // A function that handles and produces null values as well.

    static Integer inc(Integer x) {

        return (x == null) ? null : x + 1;

    }

    static class NoopConsumer extends CheckedIntegerAction

        implements Consumer<Integer>

    {

        NoopConsumer(ExecutionMode m) { super(m); }

        public void accept(Integer x) {

            invoked();

            value = x;

        }

    }

    static class IncFunction extends CheckedIntegerAction

        implements Function<Integer,Integer>

    {

        IncFunction(ExecutionMode m) { super(m); }

        public Integer apply(Integer x) {

            invoked();

            return value = inc(x);

        }

    }

    // Choose non-commutative actions for better coverage

    // A non-commutative function that handles and produces null values as well.

    static Integer subtract(Integer x, Integer y) {

        return (x == null && y == null) ? null :

            ((x == null) ? 42 : x.intValue())

            - ((y == null) ? 99 : y.intValue());

    }

    static class SubtractAction extends CheckedIntegerAction

        implements BiConsumer<Integer, Integer>

    {

        SubtractAction(ExecutionMode m) { super(m); }

        public void accept(Integer x, Integer y) {

            invoked();

            value = subtract(x, y);

        }

    }

    static class SubtractFunction extends CheckedIntegerAction

        implements BiFunction<Integer, Integer, Integer>

    {

        SubtractFunction(ExecutionMode m) { super(m); }

        public Integer apply(Integer x, Integer y) {

            invoked();

            return value = subtract(x, y);

        }

    }

    static class Noop extends CheckedAction implements Runnable {

        Noop(ExecutionMode m) { super(m); }

        public void run() {

            invoked();

        }

    }

    static class FailingSupplier extends CheckedAction

        implements Supplier<Integer>

    {

        final CFException ex;

        FailingSupplier(ExecutionMode m) { super(m); ex = new CFException(); }

        public Integer get() {

            invoked();

            throw ex;

        }

    }

    static class FailingConsumer extends CheckedIntegerAction

        implements Consumer<Integer>

    {