--- jsr166/src/test/tck/ScheduledExecutorTest.java	2011/05/07 19:34:51	1.40
+++ jsr166/src/test/tck/ScheduledExecutorTest.java	2011/05/28 15:33:20	1.44
@@ -20,7 +20,6 @@ public class ScheduledExecutorTest exten
         return new TestSuite(ScheduledExecutorTest.class);
     }
 
-
     /**
      * execute successfully executes a runnable
      */
@@ -39,25 +38,23 @@ public class ScheduledExecutorTest exten
         }
     }
 
-
     /**
      * delayed schedule of callable successfully executes after delay
      */
     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);
@@ -69,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);
         }
@@ -92,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);
@@ -115,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);
@@ -176,7 +170,6 @@ public class ScheduledExecutorTest exten
         joinPool(p);
     }
 
-
     /**
      * execute(null) throws NPE
      */
@@ -331,8 +324,12 @@ public class ScheduledExecutorTest exten
             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);
         }
@@ -459,7 +456,7 @@ public class ScheduledExecutorTest exten
     }
 
     /**
-     * isShutDown is false before shutdown, true after
+     * isShutdown is false before shutdown, true after
      */
     public void testIsShutdown() {
 
@@ -473,7 +470,6 @@ public class ScheduledExecutorTest exten
         assertTrue(p.isShutdown());
     }
 
-
     /**
      * isTerminated is false before termination, true after
      */
@@ -617,7 +613,7 @@ public class ScheduledExecutorTest exten
     }
 
     /**
-     * shutDownNow returns a list containing tasks that were not run
+     * shutdownNow returns a list containing tasks that were not run
      */
     public void testShutdownNow() {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
@@ -639,7 +635,7 @@ public class ScheduledExecutorTest exten
      * In default setting, shutdown cancels periodic but not delayed
      * tasks at shutdown
      */
-    public void testShutDown1() throws InterruptedException {
+    public void testShutdown1() throws InterruptedException {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
         assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
         assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
@@ -664,12 +660,11 @@ public class ScheduledExecutorTest exten
         }
     }
 
-
     /**
      * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
      * delayed tasks are cancelled at shutdown
      */
-    public void testShutDown2() throws InterruptedException {
+    public void testShutdown2() throws InterruptedException {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
         p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
         assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
@@ -695,30 +690,30 @@ public class ScheduledExecutorTest exten
      * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
      * periodic tasks are cancelled at shutdown
      */
-    public void testShutDown3() throws InterruptedException {
+    public void testShutdown3() throws InterruptedException {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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 {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
         final CountDownLatch counter = new CountDownLatch(2);
         try {
@@ -1175,5 +1170,4 @@ public class ScheduledExecutorTest exten
         }
     }
 
-
 }