--- jsr166/src/test/tck/ScheduledExecutorSubclassTest.java 2011/04/14 22:55:08 1.20 +++ jsr166/src/test/tck/ScheduledExecutorSubclassTest.java 2015/09/28 02:41:29 1.40 @@ -4,15 +4,38 @@ * http://creativecommons.org/publicdomain/zero/1.0/ */ -import junit.framework.*; -import java.util.*; -import java.util.concurrent.*; import static java.util.concurrent.TimeUnit.MILLISECONDS; -import java.util.concurrent.atomic.*; +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) { - junit.textui.TestRunner.run(suite()); + main(suite(), args); } public static Test suite() { return new TestSuite(ScheduledExecutorSubclassTest.class); @@ -36,19 +59,18 @@ public class ScheduledExecutorSubclassTe } public boolean isCancelled() { return task.isCancelled(); } public boolean isDone() { return task.isDone(); } - public V get() throws InterruptedException, ExecutionException { + 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 { + 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 RunnableScheduledFuture decorateTask(Runnable r, RunnableScheduledFuture task) { @@ -58,7 +80,7 @@ public class ScheduledExecutorSubclassTe protected RunnableScheduledFuture decorateTask(Callable c, RunnableScheduledFuture task) { return new CustomTask(task); } - CustomExecutor(int corePoolSize) { super(corePoolSize);} + CustomExecutor(int corePoolSize) { super(corePoolSize); } CustomExecutor(int corePoolSize, RejectedExecutionHandler handler) { super(corePoolSize, handler); } @@ -73,7 +95,6 @@ public class ScheduledExecutorSubclassTe } - /** * execute successfully executes a runnable */ @@ -92,25 +113,23 @@ public class ScheduledExecutorSubclassTe } } - /** * delayed schedule of callable successfully executes after delay */ public void testSchedule1() throws Exception { CustomExecutor p = new CustomExecutor(1); - final long t0 = System.nanoTime(); - final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L; + final long startTime = System.nanoTime(); final CountDownLatch done = new CountDownLatch(1); try { Callable task = new CheckedCallable() { public Boolean realCall() { done.countDown(); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); return Boolean.TRUE; }}; - Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS); - assertEquals(Boolean.TRUE, f.get()); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + Future f = p.schedule(task, timeoutMillis(), MILLISECONDS); + assertSame(Boolean.TRUE, f.get()); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); assertTrue(done.await(0L, MILLISECONDS)); } finally { joinPool(p); @@ -122,19 +141,18 @@ public class ScheduledExecutorSubclassTe */ public void testSchedule3() throws Exception { CustomExecutor p = new CustomExecutor(1); - final long t0 = System.nanoTime(); - final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L; + final long startTime = System.nanoTime(); final CountDownLatch done = new CountDownLatch(1); try { Runnable task = new CheckedRunnable() { public void realRun() { done.countDown(); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); }}; - Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS); - assertNull(f.get()); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); - assertTrue(done.await(0L, MILLISECONDS)); + Future f = p.schedule(task, timeoutMillis(), MILLISECONDS); + await(done); + assertNull(f.get(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); } finally { joinPool(p); } @@ -145,20 +163,19 @@ public class ScheduledExecutorSubclassTe */ public void testSchedule4() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); - final long t0 = System.nanoTime(); - final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L; + final long startTime = System.nanoTime(); final CountDownLatch done = new CountDownLatch(1); try { Runnable task = new CheckedRunnable() { public void realRun() { done.countDown(); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); }}; ScheduledFuture f = - p.scheduleAtFixedRate(task, SHORT_DELAY_MS, - SHORT_DELAY_MS, MILLISECONDS); - assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS)); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + p.scheduleAtFixedRate(task, timeoutMillis(), + LONG_DELAY_MS, MILLISECONDS); + await(done); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); f.cancel(true); } finally { joinPool(p); @@ -170,20 +187,19 @@ public class ScheduledExecutorSubclassTe */ public void testSchedule5() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); - final long t0 = System.nanoTime(); - final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L; + final long startTime = System.nanoTime(); final CountDownLatch done = new CountDownLatch(1); try { Runnable task = new CheckedRunnable() { public void realRun() { done.countDown(); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); }}; ScheduledFuture f = - p.scheduleWithFixedDelay(task, SHORT_DELAY_MS, - SHORT_DELAY_MS, MILLISECONDS); - assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS)); - assertTrue(System.nanoTime() - t0 >= timeoutNanos); + p.scheduleWithFixedDelay(task, timeoutMillis(), + LONG_DELAY_MS, MILLISECONDS); + await(done); + assertTrue(millisElapsedSince(startTime) >= timeoutMillis()); f.cancel(true); } finally { joinPool(p); @@ -200,17 +216,27 @@ public class ScheduledExecutorSubclassTe */ public void testFixedRateSequence() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); - RunnableCounter counter = new RunnableCounter(); - ScheduledFuture h = - p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS); - Thread.sleep(SMALL_DELAY_MS); - h.cancel(true); - int c = counter.count.get(); - // By time scaling conventions, we must have at least - // an execution per SHORT delay, but no more than one SHORT more - assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); - assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); - joinPool(p); + try { + for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) { + long startTime = System.nanoTime(); + int cycles = 10; + final CountDownLatch done = new CountDownLatch(cycles); + Runnable task = new CheckedRunnable() { + public void realRun() { done.countDown(); }}; + ScheduledFuture h = + p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS); + done.await(); + h.cancel(true); + double normalizedTime = + (double) millisElapsedSince(startTime) / delay; + if (normalizedTime >= cycles - 1 && + normalizedTime <= cycles) + return; + } + throw new AssertionError("unexpected execution rate"); + } finally { + joinPool(p); + } } /** @@ -218,18 +244,29 @@ public class ScheduledExecutorSubclassTe */ public void testFixedDelaySequence() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); - RunnableCounter counter = new RunnableCounter(); - ScheduledFuture h = - p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS); - Thread.sleep(SMALL_DELAY_MS); - h.cancel(true); - int c = counter.count.get(); - assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS); - assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS); - joinPool(p); + try { + for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) { + long startTime = System.nanoTime(); + int cycles = 10; + final CountDownLatch done = new CountDownLatch(cycles); + Runnable task = new CheckedRunnable() { + public void realRun() { done.countDown(); }}; + ScheduledFuture h = + p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS); + done.await(); + h.cancel(true); + double normalizedTime = + (double) millisElapsedSince(startTime) / delay; + if (normalizedTime >= cycles - 1 && + normalizedTime <= cycles) + return; + } + throw new AssertionError("unexpected execution rate"); + } finally { + joinPool(p); + } } - /** * execute(null) throws NPE */ @@ -378,12 +415,16 @@ public class ScheduledExecutorSubclassTe threadProceed.await(); threadDone.countDown(); }}); - assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS)); + await(threadStarted); assertEquals(0, p.getCompletedTaskCount()); threadProceed.countDown(); threadDone.await(); - Thread.sleep(SHORT_DELAY_MS); - assertEquals(1, p.getCompletedTaskCount()); + long startTime = System.nanoTime(); + while (p.getCompletedTaskCount() != 1) { + if (millisElapsedSince(startTime) > LONG_DELAY_MS) + fail("timed out"); + Thread.yield(); + } } finally { joinPool(p); } @@ -510,7 +551,7 @@ public class ScheduledExecutorSubclassTe } /** - * isShutDown is false before shutdown, true after + * isShutdown is false before shutdown, true after */ public void testIsShutdown() { CustomExecutor p = new CustomExecutor(1); @@ -523,7 +564,6 @@ public class ScheduledExecutorSubclassTe assertTrue(p.isShutdown()); } - /** * isTerminated is false before termination, true after */ @@ -642,24 +682,23 @@ public class ScheduledExecutorSubclassTe public void testPurge() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); ScheduledFuture[] tasks = new ScheduledFuture[5]; - for (int i = 0; i < tasks.length; i++) { - tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS); - } + for (int i = 0; i < tasks.length; i++) + tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), + LONG_DELAY_MS, MILLISECONDS); try { int max = tasks.length; if (tasks[4].cancel(true)) --max; if (tasks[3].cancel(true)) --max; // There must eventually be an interference-free point at // which purge will not fail. (At worst, when queue is empty.) - int k; - for (k = 0; k < SMALL_DELAY_MS; ++k) { + long startTime = System.nanoTime(); + do { p.purge(); long count = p.getTaskCount(); - if (count >= 0 && count <= max) - break; - Thread.sleep(1); - } - assertTrue(k < SMALL_DELAY_MS); + if (count == max) + return; + } while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS); + fail("Purge failed to remove cancelled tasks"); } finally { for (ScheduledFuture task : tasks) task.cancel(true); @@ -668,28 +707,79 @@ public class ScheduledExecutorSubclassTe } /** - * shutDownNow returns a list containing tasks that were not run + * shutdownNow returns a list containing tasks that were not run, + * and those tasks are drained from the queue */ - public void testShutDownNow() { + public void testShutdownNow() throws InterruptedException { + final int poolSize = 2; + final int count = 5; + final AtomicInteger ran = new AtomicInteger(0); + final CustomExecutor p = new CustomExecutor(poolSize); + CountDownLatch threadsStarted = new CountDownLatch(poolSize); + CheckedRunnable waiter = new CheckedRunnable() { public void realRun() { + threadsStarted.countDown(); + try { + MILLISECONDS.sleep(2 * LONG_DELAY_MS); + } catch (InterruptedException success) {} + ran.getAndIncrement(); + }}; + for (int i = 0; i < count; i++) + p.execute(waiter); + assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS)); + final List queuedTasks; + try { + queuedTasks = p.shutdownNow(); + } catch (SecurityException ok) { + return; // Allowed in case test doesn't have privs + } + assertTrue(p.isShutdown()); + assertTrue(p.getQueue().isEmpty()); + assertEquals(count - poolSize, queuedTasks.size()); + assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p.isTerminated()); + assertEquals(poolSize, ran.get()); + } + + /** + * shutdownNow returns a list containing tasks that were not run, + * and those tasks are drained from the queue + */ + public void testShutdownNow_delayedTasks() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); - for (int i = 0; i < 5; i++) - p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS); - List l; + List tasks = new ArrayList<>(); + for (int i = 0; i < 3; i++) { + Runnable r = new NoOpRunnable(); + tasks.add(p.schedule(r, 9, SECONDS)); + tasks.add(p.scheduleAtFixedRate(r, 9, 9, SECONDS)); + tasks.add(p.scheduleWithFixedDelay(r, 9, 9, SECONDS)); + } + if (testImplementationDetails) + assertEquals(new HashSet(tasks), new HashSet(p.getQueue())); + final List queuedTasks; try { - l = p.shutdownNow(); + queuedTasks = p.shutdownNow(); } catch (SecurityException ok) { - return; + return; // Allowed in case test doesn't have privs } assertTrue(p.isShutdown()); - assertTrue(l.size() > 0 && l.size() <= 5); - joinPool(p); + assertTrue(p.getQueue().isEmpty()); + if (testImplementationDetails) + assertEquals(new HashSet(tasks), new HashSet(queuedTasks)); + assertEquals(tasks.size(), queuedTasks.size()); + for (ScheduledFuture task : tasks) { + assertFalse(((CustomTask)task).ran); + assertFalse(task.isDone()); + assertFalse(task.isCancelled()); + } + assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS)); + assertTrue(p.isTerminated()); } /** * In default setting, shutdown cancels periodic but not delayed * tasks at shutdown */ - public void testShutDown1() throws InterruptedException { + public void testShutdown1() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy()); assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy()); @@ -714,12 +804,11 @@ public class ScheduledExecutorSubclassTe } } - /** * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false, * delayed tasks are cancelled at shutdown */ - public void testShutDown2() throws InterruptedException { + public void testShutdown2() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false); assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy()); @@ -741,35 +830,34 @@ public class ScheduledExecutorSubclassTe } } - /** * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false, * periodic tasks are cancelled at shutdown */ - public void testShutDown3() throws InterruptedException { + public void testShutdown3() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy()); assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy()); p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false); assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy()); assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy()); + long initialDelay = LONG_DELAY_MS; ScheduledFuture task = - p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS); + p.scheduleAtFixedRate(new NoOpRunnable(), initialDelay, + 5, MILLISECONDS); try { p.shutdown(); } catch (SecurityException ok) { return; } assertTrue(p.isShutdown()); - BlockingQueue q = p.getQueue(); assertTrue(p.getQueue().isEmpty()); assertTrue(task.isDone()); assertTrue(task.isCancelled()); - assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS)); - assertTrue(p.isTerminated()); + joinPool(p); } /** * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true, * periodic tasks are not cancelled at shutdown */ - public void testShutDown4() throws InterruptedException { + public void testShutdown4() throws InterruptedException { CustomExecutor p = new CustomExecutor(1); final CountDownLatch counter = new CountDownLatch(2); try { @@ -1205,22 +1293,29 @@ public class ScheduledExecutorSubclassTe public void testTimedInvokeAll6() throws Exception { ExecutorService e = new CustomExecutor(2); try { - List> l = new ArrayList>(); - l.add(new StringTask()); - l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); - l.add(new StringTask()); - List> futures = - e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS); - assertEquals(3, futures.size()); - Iterator> it = futures.iterator(); - Future f1 = it.next(); - Future f2 = it.next(); - Future f3 = it.next(); - assertTrue(f1.isDone()); - assertTrue(f2.isDone()); - assertTrue(f3.isDone()); - assertFalse(f1.isCancelled()); - assertTrue(f2.isCancelled()); + for (long timeout = timeoutMillis();;) { + List> tasks = new ArrayList<>(); + tasks.add(new StringTask("0")); + tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING)); + tasks.add(new StringTask("2")); + long startTime = System.nanoTime(); + List> futures = + e.invokeAll(tasks, timeout, MILLISECONDS); + assertEquals(tasks.size(), futures.size()); + assertTrue(millisElapsedSince(startTime) >= timeout); + for (Future future : futures) + assertTrue(future.isDone()); + assertTrue(futures.get(1).isCancelled()); + try { + assertEquals("0", futures.get(0).get()); + assertEquals("2", futures.get(2).get()); + break; + } catch (CancellationException retryWithLongerTimeout) { + timeout *= 2; + if (timeout >= LONG_DELAY_MS / 2) + fail("expected exactly one task to be cancelled"); + } + } } finally { joinPool(e); }