--- jsr166/src/test/tck/ScheduledExecutorTest.java	2010/11/17 23:12:31	1.35
+++ jsr166/src/test/tck/ScheduledExecutorTest.java	2011/05/07 19:34:51	1.40
@@ -1,7 +1,7 @@
 /*
  * 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/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  * Other contributors include Andrew Wright, Jeffrey Hayes,
  * Pat Fisher, Mike Judd.
  */
@@ -150,7 +150,7 @@ public class ScheduledExecutorTest exten
         RunnableCounter counter = new RunnableCounter();
         ScheduledFuture h =
             p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
-        Thread.sleep(SMALL_DELAY_MS);
+        delay(SMALL_DELAY_MS);
         h.cancel(true);
         int c = counter.count.get();
         // By time scaling conventions, we must have at least
@@ -168,7 +168,7 @@ public class ScheduledExecutorTest exten
         RunnableCounter counter = new RunnableCounter();
         ScheduledFuture h =
             p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
-        Thread.sleep(SMALL_DELAY_MS);
+        delay(SMALL_DELAY_MS);
         h.cancel(true);
         int c = counter.count.get();
         assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
@@ -240,9 +240,9 @@ public class ScheduledExecutorTest exten
     /**
      * schedule callable throws RejectedExecutionException if shutdown
      */
-     public void testSchedule3_RejectedExecutionException() throws InterruptedException {
-         ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
-         try {
+    public void testSchedule3_RejectedExecutionException() throws InterruptedException {
+        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
+        try {
             se.shutdown();
             se.schedule(new NoOpCallable(),
                         MEDIUM_DELAY_MS, MILLISECONDS);
@@ -250,7 +250,7 @@ public class ScheduledExecutorTest exten
         } catch (RejectedExecutionException success) {
         } catch (SecurityException ok) {
         }
-         joinPool(se);
+        joinPool(se);
     }
 
     /**
@@ -331,7 +331,7 @@ public class ScheduledExecutorTest exten
             assertEquals(0, p.getCompletedTaskCount());
             threadProceed.countDown();
             threadDone.await();
-            Thread.sleep(SHORT_DELAY_MS);
+            delay(SHORT_DELAY_MS);
             assertEquals(1, p.getCompletedTaskCount());
         } finally {
             joinPool(p);
@@ -485,11 +485,12 @@ public class ScheduledExecutorTest exten
         try {
             p.execute(new CheckedRunnable() {
                 public void realRun() throws InterruptedException {
-                    threadStarted.countDown();
                     assertFalse(p.isTerminated());
+                    threadStarted.countDown();
                     done.await();
                 }});
             assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
+            assertFalse(p.isTerminating());
             done.countDown();
         } finally {
             try { p.shutdown(); } catch (SecurityException ok) { return; }
@@ -586,29 +587,28 @@ public class ScheduledExecutorTest exten
     }
 
     /**
-     * purge removes cancelled tasks from the queue
+     * purge eventually removes cancelled tasks from the queue
      */
     public void testPurge() throws InterruptedException {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(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);
@@ -619,19 +619,20 @@ public class ScheduledExecutorTest exten
     /**
      * shutDownNow returns a list containing tasks that were not run
      */
-    public void testShutDownNow() throws InterruptedException {
+    public void testShutdownNow() {
         ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
         for (int i = 0; i < 5; i++)
-            p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
-        List l;
+            p.schedule(new SmallPossiblyInterruptedRunnable(),
+                       LONG_DELAY_MS, MILLISECONDS);
         try {
-            l = p.shutdownNow();
+            List<Runnable> l = p.shutdownNow();
+            assertTrue(p.isShutdown());
+            assertEquals(5, l.size());
         } catch (SecurityException ok) {
-            return;
+            // Allowed in case test doesn't have privs
+        } finally {
+            joinPool(p);
         }
-        assertTrue(p.isShutdown());
-        assertTrue(l.size() > 0 && l.size() <= 5);
-        joinPool(p);
     }
 
     /**