/*

 * 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 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 java.util.HashSet;

import java.util.concurrent.CancellationException;

import java.util.concurrent.CountedCompleter;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.ForkJoinTask;

import java.util.concurrent.ThreadLocalRandom;

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

import junit.framework.Test;

import junit.framework.TestSuite;

public class CountedCompleterTest extends JSR166TestCase {

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        return new TestSuite(CountedCompleterTest.class);

    }

    // Runs with "mainPool" use > 1 thread. singletonPool tests use 1

    static final int mainPoolSize =

        Math.max(2, Runtime.getRuntime().availableProcessors());

    private static ForkJoinPool mainPool() {

        return new ForkJoinPool(mainPoolSize);

    }

    private static ForkJoinPool singletonPool() {

        return new ForkJoinPool(1);

    }

    private static ForkJoinPool asyncSingletonPool() {

        return new ForkJoinPool(1,

                                ForkJoinPool.defaultForkJoinWorkerThreadFactory,

                                null, true);

    }

    private void testInvokeOnPool(ForkJoinPool pool, ForkJoinTask a) {

        try (PoolCleaner cleaner = cleaner(pool)) {

            assertFalse(a.isDone());

            assertFalse(a.isCompletedNormally());

            assertFalse(a.isCompletedAbnormally());

            assertFalse(a.isCancelled());

            assertNull(a.getException());

            assertNull(a.getRawResult());

            assertNull(pool.invoke(a));

            assertTrue(a.isDone());

            assertTrue(a.isCompletedNormally());

            assertFalse(a.isCompletedAbnormally());

            assertFalse(a.isCancelled());

            assertNull(a.getException());

            assertNull(a.getRawResult());

        }

    }

    void checkNotDone(CountedCompleter a) {

        assertFalse(a.isDone());

        assertFalse(a.isCompletedNormally());

        assertFalse(a.isCompletedAbnormally());

        assertFalse(a.isCancelled());

        assertNull(a.getException());

        assertNull(a.getRawResult());

        try {

            a.get(0L, SECONDS);

            shouldThrow();

        } catch (TimeoutException success) {

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

    }

    void checkCompletedNormally(CountedCompleter<?> a) {

        assertTrue(a.isDone());

        assertFalse(a.isCancelled());

        assertTrue(a.isCompletedNormally());

        assertFalse(a.isCompletedAbnormally());

        assertNull(a.getException());

        assertNull(a.getRawResult());

        {

            Thread.currentThread().interrupt();

            long startTime = System.nanoTime();

            assertNull(a.join());

            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);

            Thread.interrupted();

        }

        {

            Thread.currentThread().interrupt();

            long startTime = System.nanoTime();

            a.quietlyJoin();        // should be no-op

            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);

            Thread.interrupted();

        }

        assertFalse(a.cancel(false));

        assertFalse(a.cancel(true));

        try {

            assertNull(a.get());

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

        try {

            assertNull(a.get(5L, SECONDS));

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

    }

    void checkCancelled(CountedCompleter a) {

        assertTrue(a.isDone());

        assertTrue(a.isCancelled());

        assertFalse(a.isCompletedNormally());

        assertTrue(a.isCompletedAbnormally());

        assertTrue(a.getException() instanceof CancellationException);

        assertNull(a.getRawResult());

        assertTrue(a.cancel(false));

        assertTrue(a.cancel(true));

        try {

            Thread.currentThread().interrupt();

            a.join();

            shouldThrow();

        } catch (CancellationException success) {

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

        Thread.interrupted();

        {

            long startTime = System.nanoTime();

            a.quietlyJoin();        // should be no-op

            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);

        }

        try {

            a.get();

            shouldThrow();

        } catch (CancellationException success) {

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

        try {

            a.get(5L, SECONDS);

            shouldThrow();

        } catch (CancellationException success) {

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

    }

    void checkCompletedAbnormally(CountedCompleter a, Throwable t) {

        assertTrue(a.isDone());

        assertFalse(a.isCancelled());

        assertFalse(a.isCompletedNormally());

        assertTrue(a.isCompletedAbnormally());

        assertSame(t.getClass(), a.getException().getClass());

        assertNull(a.getRawResult());

        assertFalse(a.cancel(false));

        assertFalse(a.cancel(true));

        try {

            Thread.currentThread().interrupt();

            a.join();

            shouldThrow();

        } catch (Throwable expected) {

            assertSame(t.getClass(), expected.getClass());

        }

        Thread.interrupted();

        {

            long startTime = System.nanoTime();

            a.quietlyJoin();        // should be no-op

            assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);

        }

        try {

            a.get();

            shouldThrow();

        } catch (ExecutionException success) {

            assertSame(t.getClass(), success.getCause().getClass());

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

        try {

            a.get(5L, SECONDS);

            shouldThrow();

        } catch (ExecutionException success) {

            assertSame(t.getClass(), success.getCause().getClass());

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

        try {

            a.invoke();

            shouldThrow();

        } catch (Throwable success) {

            assertSame(t, success);

        }

    }

    public static final class FJException extends RuntimeException {

        FJException() { super(); }

    }

    abstract class CheckedCC extends CountedCompleter<Object> {

        final AtomicInteger computeN = new AtomicInteger(0);

        final AtomicInteger onCompletionN = new AtomicInteger(0);

        final AtomicInteger onExceptionalCompletionN = new AtomicInteger(0);

        final AtomicInteger setRawResultN = new AtomicInteger(0);

        final AtomicReference<Object> rawResult = new AtomicReference<Object>(null);

        int computeN() { return computeN.get(); }

        int onCompletionN() { return onCompletionN.get(); }

        int onExceptionalCompletionN() { return onExceptionalCompletionN.get(); }

        int setRawResultN() { return setRawResultN.get(); }

        CheckedCC() { super(); }

        CheckedCC(CountedCompleter p) { super(p); }

        CheckedCC(CountedCompleter p, int n) { super(p, n); }

        abstract void realCompute();

        public final void compute() {

            computeN.incrementAndGet();

            realCompute();

        }

        public void onCompletion(CountedCompleter caller) {

            onCompletionN.incrementAndGet();

            super.onCompletion(caller);

        }

        public boolean onExceptionalCompletion(Throwable ex,

                                               CountedCompleter caller) {

            onExceptionalCompletionN.incrementAndGet();

            assertNotNull(ex);

            assertTrue(isCompletedAbnormally());

            assertTrue(super.onExceptionalCompletion(ex, caller));

            return true;

        }

        protected void setRawResult(Object t) {

            setRawResultN.incrementAndGet();

            rawResult.set(t);

            super.setRawResult(t);

        }

        void checkIncomplete() {

            assertEquals(0, computeN());

            assertEquals(0, onCompletionN());

            assertEquals(0, onExceptionalCompletionN());

            assertEquals(0, setRawResultN());

            checkNotDone(this);

        }

        void checkCompletes(Object rawResult) {

            checkIncomplete();

            int pendingCount = getPendingCount();

            complete(rawResult);

            assertEquals(pendingCount, getPendingCount());

            assertEquals(0, computeN());

            assertEquals(1, onCompletionN());

            assertEquals(0, onExceptionalCompletionN());

            assertEquals(1, setRawResultN());

            assertSame(rawResult, this.rawResult.get());

            checkCompletedNormally(this);

        }

        void checkCompletesExceptionally(Throwable ex) {

            checkIncomplete();

            completeExceptionally(ex);

            checkCompletedExceptionally(ex);

        }

        void checkCompletedExceptionally(Throwable ex) {

            assertEquals(0, computeN());

            assertEquals(0, onCompletionN());

            assertEquals(1, onExceptionalCompletionN());

            assertEquals(0, setRawResultN());

            assertNull(this.rawResult.get());

            checkCompletedAbnormally(this, ex);

        }

    }

    final class NoopCC extends CheckedCC {

        NoopCC() { super(); }

        NoopCC(CountedCompleter p) { super(p); }

        NoopCC(CountedCompleter p, int initialPendingCount) {

            super(p, initialPendingCount);

        }

        protected void realCompute() {}

    }

    /**

     * A newly constructed CountedCompleter is not completed;

     * complete() causes completion. pendingCount is ignored.

     */

    public void testComplete() {

        for (Object x : new Object[] { Boolean.TRUE, null }) {

            for (int pendingCount : new int[] { 0, 42 }) {

                testComplete(new NoopCC(), x, pendingCount);

                testComplete(new NoopCC(new NoopCC()), x, pendingCount);

            }

        }

    }

    void testComplete(NoopCC cc, Object x, int pendingCount) {

        cc.setPendingCount(pendingCount);

        cc.checkCompletes(x);

        assertEquals(pendingCount, cc.getPendingCount());

    }

    /**

     * completeExceptionally completes exceptionally

     */

    public void testCompleteExceptionally() {

        new NoopCC()

            .checkCompletesExceptionally(new FJException());

        new NoopCC(new NoopCC())

            .checkCompletesExceptionally(new FJException());

    }

    /**

     * completeExceptionally(null) surprisingly has the same effect as

     * completeExceptionally(new RuntimeException())

     */

    public void testCompleteExceptionally_null() {

        NoopCC a = new NoopCC();

        a.completeExceptionally(null);

        try {

            a.invoke();

            shouldThrow();

        } catch (RuntimeException success) {

            assertSame(success.getClass(), RuntimeException.class);

            assertNull(success.getCause());

            a.checkCompletedExceptionally(success);

        }

    }

    /**

     * setPendingCount sets the reported pending count

     */

    public void testSetPendingCount() {

        NoopCC a = new NoopCC();

        assertEquals(0, a.getPendingCount());

        int[] vals = {

             -1, 0, 1,

             Integer.MIN_VALUE,

             Integer.MAX_VALUE,

        };

        for (int val : vals) {

            a.setPendingCount(val);

            assertEquals(val, a.getPendingCount());

        }

    }

    /**

     * addToPendingCount adds to the reported pending count

     */

    public void testAddToPendingCount() {

        NoopCC a = new NoopCC();

        assertEquals(0, a.getPendingCount());

        a.addToPendingCount(1);

        assertEquals(1, a.getPendingCount());

        a.addToPendingCount(27);

        assertEquals(28, a.getPendingCount());

        a.addToPendingCount(-28);

        assertEquals(0, a.getPendingCount());

    }

    /**

     * decrementPendingCountUnlessZero decrements reported pending

     * count unless zero

     */

    public void testDecrementPendingCountUnlessZero() {

        NoopCC a = new NoopCC(null, 2);

        assertEquals(2, a.getPendingCount());

        assertEquals(2, a.decrementPendingCountUnlessZero());

        assertEquals(1, a.getPendingCount());

        assertEquals(1, a.decrementPendingCountUnlessZero());

        assertEquals(0, a.getPendingCount());

        assertEquals(0, a.decrementPendingCountUnlessZero());

        assertEquals(0, a.getPendingCount());

        a.setPendingCount(-1);

        assertEquals(-1, a.decrementPendingCountUnlessZero());

        assertEquals(-2, a.getPendingCount());

    }

    /**

     * compareAndSetPendingCount compares and sets the reported

     * pending count

     */

    public void testCompareAndSetPendingCount() {

        NoopCC a = new NoopCC();

        assertEquals(0, a.getPendingCount());

        assertTrue(a.compareAndSetPendingCount(0, 1));

        assertEquals(1, a.getPendingCount());

        assertTrue(a.compareAndSetPendingCount(1, 2));

        assertEquals(2, a.getPendingCount());

        assertFalse(a.compareAndSetPendingCount(1, 3));

        assertEquals(2, a.getPendingCount());

    }

    /**

     * getCompleter returns parent or null if at root

     */

    public void testGetCompleter() {

        NoopCC a = new NoopCC();

        assertNull(a.getCompleter());

        CountedCompleter b = new NoopCC(a);

        assertSame(a, b.getCompleter());

        CountedCompleter c = new NoopCC(b);

        assertSame(b, c.getCompleter());

    }

    /**

     * getRoot returns self if no parent, else parent's root

     */

    public void testGetRoot() {

        NoopCC a = new NoopCC();

        NoopCC b = new NoopCC(a);

        NoopCC c = new NoopCC(b);

        assertSame(a, a.getRoot());

        assertSame(a, b.getRoot());

        assertSame(a, c.getRoot());

    }

    /**

     * tryComplete decrements pending count unless zero, in which case

     * causes completion

     */

    public void testTryComplete() {

        NoopCC a = new NoopCC();

        assertEquals(0, a.getPendingCount());

        int n = 3;

        a.setPendingCount(n);

        for (; n > 0; n--) {

            assertEquals(n, a.getPendingCount());

            a.tryComplete();

            a.checkIncomplete();

            assertEquals(n - 1, a.getPendingCount());

        }

        a.tryComplete();

        assertEquals(0, a.computeN());

        assertEquals(1, a.onCompletionN());

        assertEquals(0, a.onExceptionalCompletionN());

        assertEquals(0, a.setRawResultN());

        checkCompletedNormally(a);

    }

    /**

     * propagateCompletion decrements pending count unless zero, in

     * which case causes completion, without invoking onCompletion

     */

    public void testPropagateCompletion() {

        NoopCC a = new NoopCC();

        assertEquals(0, a.getPendingCount());

        int n = 3;

        a.setPendingCount(n);

        for (; n > 0; n--) {

            assertEquals(n, a.getPendingCount());

            a.propagateCompletion();

            a.checkIncomplete();

            assertEquals(n - 1, a.getPendingCount());

        }

        a.propagateCompletion();

        assertEquals(0, a.computeN());

        assertEquals(0, a.onCompletionN());

        assertEquals(0, a.onExceptionalCompletionN());

        assertEquals(0, a.setRawResultN());

        checkCompletedNormally(a);

    }

    /**

     * firstComplete returns this if pending count is zero else null

     */

    public void testFirstComplete() {

        NoopCC a = new NoopCC();

        a.setPendingCount(1);

        assertNull(a.firstComplete());

        a.checkIncomplete();

        assertSame(a, a.firstComplete());

        a.checkIncomplete();

    }

    /**

     * firstComplete.nextComplete returns parent if pending count is

     * zero else null

     */

    public void testNextComplete() {

        NoopCC a = new NoopCC();

        NoopCC b = new NoopCC(a);

        a.setPendingCount(1);

        b.setPendingCount(1);

        assertNull(b.firstComplete());

        assertSame(b, b.firstComplete());

        assertNull(b.nextComplete());

        a.checkIncomplete();

        b.checkIncomplete();

        assertSame(a, b.nextComplete());

        assertSame(a, b.nextComplete());

        a.checkIncomplete();

        b.checkIncomplete();

        assertNull(a.nextComplete());

        b.checkIncomplete();

        checkCompletedNormally(a);