--- jsr166/src/test/tck/ScheduledExecutorSubclassTest.java	2011/06/10 19:45:01	1.29
+++ jsr166/src/test/tck/ScheduledExecutorSubclassTest.java	2015/04/25 04:55:31	1.35
@@ -4,15 +4,35 @@
  * 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.ArrayList;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+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,12 +56,12 @@ 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;
@@ -193,17 +213,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);
-        delay(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);
+        }
     }
 
     /**
@@ -211,15 +241,27 @@ 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);
-        delay(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);
+        }
     }
 
     /**