/*

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

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

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

import java.util.concurrent.TimeoutException;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicInteger;

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> {

        RunnableScheduledFuture<V> task;

        volatile boolean ran;

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

        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(); }

    }

    /**

     */

    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 CountDownLatch done = new CountDownLatch(cycles);

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

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

                    return;

            }

            fail("unexpected execution rate");

        }

    }

    /**

     */

    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 CountDownLatch done = new CountDownLatch(cycles);

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

                    return;

            }

            fail("unexpected execution rate");

        }

    }

    /**

     * execute(null) throws NPE

     */

    public void testExecuteNull() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                p.execute(null);

                shouldThrow();

            } catch (NullPointerException success) {}

        }

    }

    /**

     * schedule(null) throws NPE

     */

    public void testScheduleNull() throws InterruptedException {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                TrackedCallable callable = null;

                Future f = p.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);

                shouldThrow();

            } catch (NullPointerException success) {}

        }

    }

    /**

     * execute throws RejectedExecutionException if shutdown

     */

    public void testSchedule1_RejectedExecutionException() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                p.shutdown();

                p.schedule(new NoOpRunnable(),

                           MEDIUM_DELAY_MS, MILLISECONDS);

                shouldThrow();

            } catch (RejectedExecutionException success) {

            } catch (SecurityException ok) {}

        }

    }

    /**

     * schedule throws RejectedExecutionException if shutdown

     */

    public void testSchedule2_RejectedExecutionException() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                p.shutdown();

                p.schedule(new NoOpCallable(),

                           MEDIUM_DELAY_MS, MILLISECONDS);

                shouldThrow();

            } catch (RejectedExecutionException success) {

            } catch (SecurityException ok) {}

        }

    }

    /**

     * schedule callable throws RejectedExecutionException if shutdown

     */

    public void testSchedule3_RejectedExecutionException() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                p.shutdown();

                p.schedule(new NoOpCallable(),

                           MEDIUM_DELAY_MS, MILLISECONDS);

                shouldThrow();

            } catch (RejectedExecutionException success) {

            } catch (SecurityException ok) {}

        }

    }

    /**

     * scheduleAtFixedRate throws RejectedExecutionException if shutdown

     */

    public void testScheduleAtFixedRate1_RejectedExecutionException() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                p.shutdown();

                p.scheduleAtFixedRate(new NoOpRunnable(),

                                      MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);

                shouldThrow();

            } catch (RejectedExecutionException success) {

            } catch (SecurityException ok) {}

        }

    }

    /**

     * scheduleWithFixedDelay throws RejectedExecutionException if shutdown

     */

    public void testScheduleWithFixedDelay1_RejectedExecutionException() {

        final CustomExecutor p = new CustomExecutor(1);

        try (PoolCleaner cleaner = cleaner(p)) {

            try {

                p.shutdown();

                p.scheduleWithFixedDelay(new NoOpRunnable(),

                                         MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);

                shouldThrow();

            } catch (RejectedExecutionException success) {

            } catch (SecurityException ok) {}

        }

    }

    /**

     * 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());

                    threadProceed.await();

                    threadDone.countDown();

                }});

            await(threadStarted);

            assertEquals(0, p.getCompletedTaskCount());

            threadProceed.countDown();

            threadDone.await();

            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

     */