/*

 * 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 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.RecursiveAction;

import java.util.concurrent.TimeoutException;

import junit.framework.Test;

import junit.framework.TestSuite;

public class ForkJoinPool8Test extends JSR166TestCase {

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        return new TestSuite(ForkJoinPool8Test.class);

    }

    /**

     * Common pool exists and has expected parallelism.

     */

    public void testCommonPoolParallelism() {

        assertEquals(ForkJoinPool.getCommonPoolParallelism(),

                     ForkJoinPool.commonPool().getParallelism());

    }

    /**

     * Common pool cannot be shut down

     */

    public void testCommonPoolShutDown() {

        assertFalse(ForkJoinPool.commonPool().isShutdown());

        assertFalse(ForkJoinPool.commonPool().isTerminating());

        assertFalse(ForkJoinPool.commonPool().isTerminated());

        ForkJoinPool.commonPool().shutdown();

        assertFalse(ForkJoinPool.commonPool().isShutdown());

        assertFalse(ForkJoinPool.commonPool().isTerminating());

        assertFalse(ForkJoinPool.commonPool().isTerminated());

        ForkJoinPool.commonPool().shutdownNow();

        assertFalse(ForkJoinPool.commonPool().isShutdown());

        assertFalse(ForkJoinPool.commonPool().isTerminating());

        assertFalse(ForkJoinPool.commonPool().isTerminated());

    }

    /*

     * All of the following test methods are adaptations of those for

     * RecursiveAction and CountedCompleter, but with all actions

     * executed in the common pool, generally implicitly via

     * checkInvoke.

     */

    private void checkInvoke(ForkJoinTask a) {

        checkNotDone(a);

        assertNull(a.invoke());

        checkCompletedNormally(a);

    }

    void checkNotDone(ForkJoinTask a) {

        assertFalse(a.isDone());

        assertFalse(a.isCompletedNormally());

        assertFalse(a.isCompletedAbnormally());

        assertFalse(a.isCancelled());

        assertNull(a.getException());

        assertNull(a.getRawResult());

        if (! ForkJoinTask.inForkJoinPool()) {

            Thread.currentThread().interrupt();

            try {

                a.get();

                shouldThrow();

            } catch (InterruptedException success) {

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

            Thread.currentThread().interrupt();

            try {

                shouldThrow();

            } catch (InterruptedException success) {

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

        }

        try {

            shouldThrow();

        } catch (TimeoutException success) {

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

    }

    void checkCompletedNormally(ForkJoinTask a) {

        assertTrue(a.isDone());

        assertFalse(a.isCancelled());

        assertTrue(a.isCompletedNormally());

        assertFalse(a.isCompletedAbnormally());

        assertNull(a.getException());

        assertNull(a.getRawResult());

        assertNull(a.join());

        assertFalse(a.cancel(false));

        assertFalse(a.cancel(true));

        try {

            assertNull(a.get());

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

    }

    void checkCancelled(ForkJoinTask a) {

        assertTrue(a.isDone());

        assertTrue(a.isCancelled());

        assertFalse(a.isCompletedNormally());

        assertTrue(a.isCompletedAbnormally());

        assertTrue(a.getException() instanceof CancellationException);

        assertNull(a.getRawResult());

        try {

            a.join();

            shouldThrow();

        } catch (CancellationException success) {

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

        try {

            a.get();

            shouldThrow();

        } catch (CancellationException success) {

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

        try {

            shouldThrow();

        } catch (CancellationException success) {

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

    }

    void checkCompletedAbnormally(ForkJoinTask 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 {

            a.join();

            shouldThrow();

        } catch (Throwable expected) {

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

        }

        try {

            a.get();

            shouldThrow();

        } catch (ExecutionException success) {

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

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

        try {

            shouldThrow();

        } catch (ExecutionException success) {

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

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

    }

    public static final class FJException extends RuntimeException {

        public FJException() { super(); }

        public FJException(Throwable cause) { super(cause); }

    }

    /** A simple recursive action for testing. */

    final class FibAction extends CheckedRecursiveAction {

        final int number;

        int result;

        FibAction(int n) { number = n; }

        protected void realCompute() {

            int n = number;

            if (n <= 1)

                result = n;

            else {

                FibAction f1 = new FibAction(n - 1);

                FibAction f2 = new FibAction(n - 2);

                invokeAll(f1, f2);

                result = f1.result + f2.result;

            }

        }

    }

    /** A recursive action failing in base case. */

    static final class FailingFibAction extends RecursiveAction {

        final int number;

        int result;

        FailingFibAction(int n) { number = n; }

        public void compute() {

            int n = number;

            if (n <= 1)

                throw new FJException();

            else {

                FailingFibAction f1 = new FailingFibAction(n - 1);

                FailingFibAction f2 = new FailingFibAction(n - 2);

                invokeAll(f1, f2);

                result = f1.result + f2.result;

            }

        }

    }

    /**

     * invoke returns when task completes normally.

     * isCompletedAbnormally and isCancelled return false for normally

     * completed tasks. getRawResult of a RecursiveAction returns null;

     */

    public void testInvoke() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FibAction f = new FibAction(8);

                assertNull(f.invoke());

                assertEquals(21, f.result);

                checkCompletedNormally(f);

            }};

        checkInvoke(a);

    }

    /**

     * quietlyInvoke task returns when task completes normally.

     * isCompletedAbnormally and isCancelled return false for normally

     * completed tasks

     */

    public void testQuietlyInvoke() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FibAction f = new FibAction(8);

                f.quietlyInvoke();

                assertEquals(21, f.result);

                checkCompletedNormally(f);

            }};

        checkInvoke(a);

    }

    /**

     * join of a forked task returns when task completes

     */

    public void testForkJoin() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FibAction f = new FibAction(8);

                assertSame(f, f.fork());

                assertNull(f.join());

                assertEquals(21, f.result);

                checkCompletedNormally(f);

            }};

        checkInvoke(a);

    }

    /**

     * join/quietlyJoin of a forked task succeeds in the presence of interrupts

     */

    public void testJoinIgnoresInterrupts() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FibAction f = new FibAction(8);

                final Thread currentThread = Thread.currentThread();

                // test join()

                assertSame(f, f.fork());

                currentThread.interrupt();

                assertNull(f.join());

                Thread.interrupted();

                assertEquals(21, f.result);

                checkCompletedNormally(f);

                f = new FibAction(8);

                f.cancel(true);

                assertSame(f, f.fork());

                currentThread.interrupt();

                try {

                    f.join();

                    shouldThrow();

                } catch (CancellationException success) {

                    Thread.interrupted();

                    checkCancelled(f);

                }

                f = new FibAction(8);

                f.completeExceptionally(new FJException());

                assertSame(f, f.fork());

                currentThread.interrupt();

                try {

                    f.join();

                    shouldThrow();

                } catch (FJException success) {

                    Thread.interrupted();

                    checkCompletedAbnormally(f, success);

                }

                // test quietlyJoin()

                f = new FibAction(8);

                assertSame(f, f.fork());

                currentThread.interrupt();

                f.quietlyJoin();

                Thread.interrupted();

                assertEquals(21, f.result);

                checkCompletedNormally(f);

                f = new FibAction(8);

                f.cancel(true);

                assertSame(f, f.fork());

                currentThread.interrupt();

                f.quietlyJoin();

                Thread.interrupted();

                checkCancelled(f);

                f = new FibAction(8);

                f.completeExceptionally(new FJException());

                assertSame(f, f.fork());

                currentThread.interrupt();

                f.quietlyJoin();

                Thread.interrupted();

                checkCompletedAbnormally(f, f.getException());

            }};

        checkInvoke(a);

        a.reinitialize();

        checkInvoke(a);

    }

    /**

     * get of a forked task returns when task completes

     */

    public void testForkGet() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() throws Exception {

                FibAction f = new FibAction(8);

                assertSame(f, f.fork());

                assertNull(f.get());

                assertEquals(21, f.result);

                checkCompletedNormally(f);

            }};

        checkInvoke(a);

    }

    /**

     * timed get of a forked task returns when task completes

     */

    public void testForkTimedGet() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() throws Exception {

                FibAction f = new FibAction(8);

                assertSame(f, f.fork());

                assertEquals(21, f.result);

                checkCompletedNormally(f);

            }};

        checkInvoke(a);

    }

    /**

     * timed get with null time unit throws NPE

     */

    public void testForkTimedGetNPE() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() throws Exception {

                FibAction f = new FibAction(8);

                assertSame(f, f.fork());

                try {

                    shouldThrow();

                } catch (NullPointerException success) {}

            }};

        checkInvoke(a);

    }

    /**

     * quietlyJoin of a forked task returns when task completes

     */

    public void testForkQuietlyJoin() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FibAction f = new FibAction(8);

                assertSame(f, f.fork());

                f.quietlyJoin();

                assertEquals(21, f.result);

                checkCompletedNormally(f);

            }};

        checkInvoke(a);

    }

    /**

     * invoke task throws exception when task completes abnormally

     */

    public void testAbnormalInvoke() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FailingFibAction f = new FailingFibAction(8);

                try {

                    f.invoke();

                    shouldThrow();

                } catch (FJException success) {

                    checkCompletedAbnormally(f, success);

                }

            }};

        checkInvoke(a);

    }

    /**

     * quietlyInvoke task returns when task completes abnormally

     */

    public void testAbnormalQuietlyInvoke() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FailingFibAction f = new FailingFibAction(8);

                f.quietlyInvoke();

                assertTrue(f.getException() instanceof FJException);

                checkCompletedAbnormally(f, f.getException());

            }};

        checkInvoke(a);

    }

    /**

     * join of a forked task throws exception when task completes abnormally

     */

    public void testAbnormalForkJoin() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FailingFibAction f = new FailingFibAction(8);

                assertSame(f, f.fork());

                try {

                    f.join();

                    shouldThrow();

                } catch (FJException success) {

                    checkCompletedAbnormally(f, success);

                }

            }};

        checkInvoke(a);

    }

    /**

     * get of a forked task throws exception when task completes abnormally

     */

    public void testAbnormalForkGet() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() throws Exception {

                FailingFibAction f = new FailingFibAction(8);

                assertSame(f, f.fork());

                try {

                    f.get();

                    shouldThrow();

                } catch (ExecutionException success) {

                    Throwable cause = success.getCause();

                    assertTrue(cause instanceof FJException);

                    checkCompletedAbnormally(f, cause);

                }

            }};

        checkInvoke(a);

    }

    /**

     * timed get of a forked task throws exception when task completes abnormally

     */

    public void testAbnormalForkTimedGet() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() throws Exception {

                FailingFibAction f = new FailingFibAction(8);

                assertSame(f, f.fork());

                try {

                    shouldThrow();

                } catch (ExecutionException success) {

                    Throwable cause = success.getCause();

                    assertTrue(cause instanceof FJException);

                    checkCompletedAbnormally(f, cause);

                }

            }};

        checkInvoke(a);

    }

    /**

     * quietlyJoin of a forked task returns when task completes abnormally

     */

    public void testAbnormalForkQuietlyJoin() {

        RecursiveAction a = new CheckedRecursiveAction() {

            protected void realCompute() {

                FailingFibAction f = new FailingFibAction(8);

                assertSame(f, f.fork());

                f.quietlyJoin();

                assertTrue(f.getException() instanceof FJException);

                checkCompletedAbnormally(f, f.getException());

            }};

        checkInvoke(a);

    }

    /**