/*

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

import static java.util.concurrent.TimeUnit.SECONDS;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.List;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.Callable;

import java.util.concurrent.CancellationException;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Delayed;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Future;

import java.util.concurrent.RejectedExecutionException;

import java.util.concurrent.RejectedExecutionHandler;

import java.util.concurrent.RunnableScheduledFuture;

import java.util.concurrent.ScheduledFuture;

import java.util.concurrent.ScheduledThreadPoolExecutor;

import java.util.concurrent.ThreadFactory;

import java.util.concurrent.ThreadLocalRandom;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeoutException;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

import java.util.stream.Stream;

import junit.framework.Test;

import junit.framework.TestSuite;

public class ScheduledExecutorSubclassTest extends JSR166TestCase {

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        return new TestSuite(ScheduledExecutorSubclassTest.class);

    }

    static class CustomTask<V> implements RunnableScheduledFuture<V> {

        private final RunnableScheduledFuture<V> task;

        volatile boolean ran;

        CustomTask(RunnableScheduledFuture<V> task) { this.task = task; }

        public boolean isPeriodic() { return task.isPeriodic(); }

        public void run() {

            ran = true;

            task.run();

        }

        public long getDelay(TimeUnit unit) { return task.getDelay(unit); }

        public int compareTo(Delayed t) {

            return task.compareTo(((CustomTask)t).task);

        }

        public boolean cancel(boolean mayInterruptIfRunning) {

            return task.cancel(mayInterruptIfRunning);

        }

        public boolean isCancelled() { return task.isCancelled(); }

        public boolean isDone() { return task.isDone(); }

        public V get() throws InterruptedException, ExecutionException {

            V v = task.get();

            assertTrue(ran);

            return v;

        }

        public V get(long time, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {

            V v = task.get(time, unit);

            assertTrue(ran);

            return v;

        }

    }

    public class CustomExecutor extends ScheduledThreadPoolExecutor {

        protected <V> RunnableScheduledFuture<V> decorateTask(Runnable r, RunnableScheduledFuture<V> task) {

            return new CustomTask<V>(task);

        }

        protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> c, RunnableScheduledFuture<V> task) {

            return new CustomTask<V>(task);

        }

        CustomExecutor(int corePoolSize) { super(corePoolSize); }

        CustomExecutor(int corePoolSize, RejectedExecutionHandler handler) {

            super(corePoolSize, handler);

        }

        CustomExecutor(int corePoolSize, ThreadFactory threadFactory) {

            super(corePoolSize, threadFactory);

        }

        CustomExecutor(int corePoolSize, ThreadFactory threadFactory,

                       RejectedExecutionHandler handler) {

            super(corePoolSize, threadFactory, handler);

        }

    }

    /**

     * execute successfully executes a runnable

     */

    public void testExecute() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            final CountDownLatch done = new CountDownLatch(1);

            final Runnable task = new CheckedRunnable() {

                public void realRun() { done.countDown(); }};

            p.execute(task);

            await(done);

        }

    }

    /**

     * delayed schedule of callable successfully executes after delay

     */

    public void testSchedule1() throws Exception {

        final CountDownLatch done = new CountDownLatch(1);

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p, done)) {

            final long startTime = System.nanoTime();

            Callable task = new CheckedCallable<Boolean>() {

                public Boolean realCall() {

                    done.countDown();

                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

                    return Boolean.TRUE;

                }};

            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);

            assertSame(Boolean.TRUE, f.get());

            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

        }

    }

    /**

     * delayed schedule of runnable successfully executes after delay

     */

    public void testSchedule3() throws Exception {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            final long startTime = System.nanoTime();

            final CountDownLatch done = new CountDownLatch(1);

            Runnable task = new CheckedRunnable() {

                public void realRun() {

                    done.countDown();

                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

                }};

            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);

            await(done);

            assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));

            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

        }

    }

    /**

     * scheduleAtFixedRate executes runnable after given initial delay

     */

    public void testSchedule4() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            final long startTime = System.nanoTime();

            final CountDownLatch done = new CountDownLatch(1);

            Runnable task = new CheckedRunnable() {

                public void realRun() {

                    done.countDown();

                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

                }};

            ScheduledFuture f =

                p.scheduleAtFixedRate(task, timeoutMillis(),

                                      LONG_DELAY_MS, MILLISECONDS);

            await(done);

            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

            f.cancel(true);

        }

    }

    /**

     * scheduleWithFixedDelay executes runnable after given initial delay

     */

    public void testSchedule5() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            final long startTime = System.nanoTime();

            final CountDownLatch done = new CountDownLatch(1);

            Runnable task = new CheckedRunnable() {

                public void realRun() {

                    done.countDown();

                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

                }};

            ScheduledFuture f =

                p.scheduleWithFixedDelay(task, timeoutMillis(),

                                         LONG_DELAY_MS, MILLISECONDS);

            await(done);

            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());

            f.cancel(true);

        }

    }

    static class RunnableCounter implements Runnable {

        AtomicInteger count = new AtomicInteger(0);

        public void run() { count.getAndIncrement(); }

    }

    /**

     * scheduleAtFixedRate executes series of tasks at given rate.

     * Eventually, it must hold that:

     *   cycles - 1 <= elapsedMillis/delay < cycles

     */

    public void testFixedRateSequence() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {

                final long startTime = System.nanoTime();

                final int cycles = 8;

                final CountDownLatch done = new CountDownLatch(cycles);

                final Runnable task = new CheckedRunnable() {

                    public void realRun() { done.countDown(); }};

                final ScheduledFuture periodicTask =

                    p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);

                final int totalDelayMillis = (cycles - 1) * delay;

                await(done, totalDelayMillis + LONG_DELAY_MS);

                periodicTask.cancel(true);

                final long elapsedMillis = millisElapsedSince(startTime);

                assertTrue(elapsedMillis >= totalDelayMillis);

                if (elapsedMillis <= cycles * delay)

                    return;

                // else retry with longer delay

            }

            fail("unexpected execution rate");

        }

    }

    /**

     * scheduleWithFixedDelay executes series of tasks with given period.

     * Eventually, it must hold that each task starts at least delay and at

     * most 2 * delay after the termination of the previous task.

     */

    public void testFixedDelaySequence() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {

                final long startTime = System.nanoTime();

                final AtomicLong previous = new AtomicLong(startTime);

                final AtomicBoolean tryLongerDelay = new AtomicBoolean(false);

                final int cycles = 8;

                final CountDownLatch done = new CountDownLatch(cycles);

                final int d = delay;

                final Runnable task = new CheckedRunnable() {

                    public void realRun() {

                        long now = System.nanoTime();

                        long elapsedMillis

                            = NANOSECONDS.toMillis(now - previous.get());

                        if (done.getCount() == cycles) { // first execution

                            if (elapsedMillis >= d)

                                tryLongerDelay.set(true);

                        } else {

                            assertTrue(elapsedMillis >= d);

                            if (elapsedMillis >= 2 * d)

                                tryLongerDelay.set(true);

                        }

                        previous.set(now);

                        done.countDown();

                    }};

                final ScheduledFuture periodicTask =

                    p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);

                final int totalDelayMillis = (cycles - 1) * delay;

                await(done, totalDelayMillis + cycles * LONG_DELAY_MS);

                periodicTask.cancel(true);

                final long elapsedMillis = millisElapsedSince(startTime);

                assertTrue(elapsedMillis >= totalDelayMillis);

                if (!tryLongerDelay.get())

                    return;

                // else retry with longer delay

            }

            fail("unexpected execution rate");

        }

    }

    /**

     * Submitting null tasks throws NullPointerException

     */

    public void testNullTaskSubmission() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            assertNullTaskSubmissionThrowsNullPointerException(p);

        }

    }

    /**

     * Submitted tasks are rejected when shutdown

     */

    public void testSubmittedTasksRejectedWhenShutdown() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(2);

        final ThreadLocalRandom rnd = ThreadLocalRandom.current();

        final CountDownLatch threadsStarted = new CountDownLatch(p.getCorePoolSize());

        final CountDownLatch done = new CountDownLatch(1);

        final Runnable r = () -> {

            threadsStarted.countDown();

            for (;;) {

                try {

                    done.await();

                    return;

                } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}

            }};

        final Callable<Boolean> c = () -> {

            threadsStarted.countDown();

            for (;;) {

                try {

                    done.await();

                    return Boolean.TRUE;

                } catch (InterruptedException shutdownNowDeliberatelyIgnored) {}

            }};

        try (PoolCleaner cleaner = cleaner(p, done)) {

            for (int i = p.getCorePoolSize(); i--> 0; ) {

                switch (rnd.nextInt(4)) {

                case 0: p.execute(r); break;

                case 1: assertFalse(p.submit(r).isDone()); break;

                case 2: assertFalse(p.submit(r, Boolean.TRUE).isDone()); break;

                case 3: assertFalse(p.submit(c).isDone()); break;

                }

            }

            // ScheduledThreadPoolExecutor has an unbounded queue, so never saturated.

            await(threadsStarted);

            if (rnd.nextBoolean())

                p.shutdownNow();

            else

                p.shutdown();

            // Pool is shutdown, but not yet terminated

            assertTaskSubmissionsAreRejected(p);

            assertFalse(p.isTerminated());

            done.countDown();   // release blocking tasks

            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));

            assertTaskSubmissionsAreRejected(p);

        }

        assertEquals(p.getCorePoolSize(), p.getCompletedTaskCount());

    }

    /**

     * getActiveCount increases but doesn't overestimate, when a

     * thread becomes active

     */

    public void testGetActiveCount() throws InterruptedException {

        final CountDownLatch done = new CountDownLatch(1);

        final ThreadPoolExecutor p = new CustomExecutor(2);

        try (PoolCleaner cleaner = cleaner(p, done)) {

            final CountDownLatch threadStarted = new CountDownLatch(1);

            assertEquals(0, p.getActiveCount());

            p.execute(new CheckedRunnable() {

                public void realRun() throws InterruptedException {

                    threadStarted.countDown();

                    assertEquals(1, p.getActiveCount());

                    await(done);

                }});

            await(threadStarted);

            assertEquals(1, p.getActiveCount());

        }

    }

    /**

     * getCompletedTaskCount increases, but doesn't overestimate,

     * when tasks complete

     */

    public void testGetCompletedTaskCount() throws InterruptedException {

        final ThreadPoolExecutor p = new CustomExecutor(2);

        try (PoolCleaner cleaner = cleaner(p)) {

            final CountDownLatch threadStarted = new CountDownLatch(1);

            final CountDownLatch threadProceed = new CountDownLatch(1);

            final CountDownLatch threadDone = new CountDownLatch(1);

            assertEquals(0, p.getCompletedTaskCount());

            p.execute(new CheckedRunnable() {

                public void realRun() throws InterruptedException {

                    threadStarted.countDown();

                    assertEquals(0, p.getCompletedTaskCount());

                    await(threadProceed);

                    threadDone.countDown();

                }});

            await(threadStarted);

            assertEquals(0, p.getCompletedTaskCount());

            threadProceed.countDown();

            await(threadDone);

            long startTime = System.nanoTime();

            while (p.getCompletedTaskCount() != 1) {

                if (millisElapsedSince(startTime) > LONG_DELAY_MS)

                    fail("timed out");

                Thread.yield();

            }

        }

    }

    /**

     * getCorePoolSize returns size given in constructor if not otherwise set

     */

    public void testGetCorePoolSize() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            assertEquals(1, p.getCorePoolSize());

        }

    }

    /**

     * getLargestPoolSize increases, but doesn't overestimate, when

     * multiple threads active

     */

    public void testGetLargestPoolSize() throws InterruptedException {

        final int THREADS = 3;

        final CountDownLatch done = new CountDownLatch(1);

        final ThreadPoolExecutor p = new CustomExecutor(THREADS);

        try (PoolCleaner cleaner = cleaner(p, done)) {

            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);

            assertEquals(0, p.getLargestPoolSize());

            for (int i = 0; i < THREADS; i++)

                p.execute(new CheckedRunnable() {

                    public void realRun() throws InterruptedException {

                        threadsStarted.countDown();

                        await(done);

                        assertEquals(THREADS, p.getLargestPoolSize());

                    }});

            await(threadsStarted);

            assertEquals(THREADS, p.getLargestPoolSize());

        }

        assertEquals(THREADS, p.getLargestPoolSize());

    }

    /**

     * getPoolSize increases, but doesn't overestimate, when threads

     * become active

     */

    public void testGetPoolSize() throws InterruptedException {

        final CountDownLatch done = new CountDownLatch(1);

        final ThreadPoolExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p, done)) {

            final CountDownLatch threadStarted = new CountDownLatch(1);

            assertEquals(0, p.getPoolSize());

            p.execute(new CheckedRunnable() {

                public void realRun() throws InterruptedException {

                    threadStarted.countDown();

                    assertEquals(1, p.getPoolSize());

                    await(done);

                }});

            await(threadStarted);

            assertEquals(1, p.getPoolSize());

        }

    }

    /**

     * getTaskCount increases, but doesn't overestimate, when tasks

     * submitted

     */

    public void testGetTaskCount() throws InterruptedException {

        final int TASKS = 3;

        final CountDownLatch done = new CountDownLatch(1);

        final ThreadPoolExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p, done)) {

            final CountDownLatch threadStarted = new CountDownLatch(1);

            assertEquals(0, p.getTaskCount());

            assertEquals(0, p.getCompletedTaskCount());

            p.execute(new CheckedRunnable() {

                public void realRun() throws InterruptedException {

                    threadStarted.countDown();

                    await(done);

                }});

            await(threadStarted);

            assertEquals(1, p.getTaskCount());

            assertEquals(0, p.getCompletedTaskCount());

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

                assertEquals(1 + i, p.getTaskCount());

                p.execute(new CheckedRunnable() {

                    public void realRun() throws InterruptedException {

                        threadStarted.countDown();

                        assertEquals(1 + TASKS, p.getTaskCount());

                        await(done);

                    }});

            }

            assertEquals(1 + TASKS, p.getTaskCount());

            assertEquals(0, p.getCompletedTaskCount());

        }

        assertEquals(1 + TASKS, p.getTaskCount());

        assertEquals(1 + TASKS, p.getCompletedTaskCount());

    }

    /**

     * getThreadFactory returns factory in constructor if not set

     */