--- jsr166/src/test/tck/ScheduledExecutorTest.java	2011/05/27 19:48:58	1.43
+++ jsr166/src/test/tck/ScheduledExecutorTest.java	2013/09/24 18:35:21	1.47
@@ -10,7 +10,7 @@ import junit.framework.*;
 import java.util.*;
 import java.util.concurrent.*;
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.concurrent.atomic.*;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class ScheduledExecutorTest extends JSR166TestCase {
     public static void main(String[] args) {
@@ -43,19 +43,18 @@ public class ScheduledExecutorTest exten
      */
     public void testSchedule1() throws Exception {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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<Boolean>() {
                 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);
@@ -67,19 +66,18 @@ public class ScheduledExecutorTest exten
      */
     public void testSchedule3() throws Exception {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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);
         }
@@ -90,20 +88,19 @@ public class ScheduledExecutorTest exten
      */
     public void testSchedule4() throws Exception {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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);
@@ -113,22 +110,21 @@ public class ScheduledExecutorTest exten
     /**
      * scheduleWithFixedDelay executes runnable after given initial delay
      */
-    public void testSchedule5() throws InterruptedException {
+    public void testSchedule5() throws Exception {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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);
@@ -145,17 +141,28 @@ public class ScheduledExecutorTest exten
      */
     public void testFixedRateSequence() throws InterruptedException {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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);
+                CheckedRunnable 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);
+        }
     }
 
     /**
@@ -163,15 +170,28 @@ public class ScheduledExecutorTest exten
      */
     public void testFixedDelaySequence() throws InterruptedException {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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);
+                CheckedRunnable 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);
+        }
     }
 
     /**
@@ -324,12 +344,16 @@ public class ScheduledExecutorTest exten
                     threadProceed.await();
                     threadDone.countDown();
                 }});
-            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
+            await(threadStarted);
             assertEquals(0, p.getCompletedTaskCount());
             threadProceed.countDown();
             threadDone.await();
-            delay(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);
         }
@@ -1155,16 +1179,11 @@ public class ScheduledExecutorTest exten
             l.add(new StringTask());
             List<Future<String>> futures =
                 e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
-            assertEquals(3, futures.size());
-            Iterator<Future<String>> it = futures.iterator();
-            Future<String> f1 = it.next();
-            Future<String> f2 = it.next();
-            Future<String> f3 = it.next();
-            assertTrue(f1.isDone());
-            assertTrue(f2.isDone());
-            assertTrue(f3.isDone());
-            assertFalse(f1.isCancelled());
-            assertTrue(f2.isCancelled());
+            assertEquals(l.size(), futures.size());
+            for (Future future : futures)
+                assertTrue(future.isDone());
+            assertFalse(futures.get(0).isCancelled());
+            assertTrue(futures.get(1).isCancelled());
         } finally {
             joinPool(e);
         }