ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ScheduledExecutorTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ScheduledExecutorTest.java (file contents):
Revision 1.37 by jsr166, Tue Mar 15 19:47:07 2011 UTC vs.
Revision 1.40 by jsr166, Sat May 7 19:34:51 2011 UTC

# Line 150 | Line 150 | public class ScheduledExecutorTest exten
150          RunnableCounter counter = new RunnableCounter();
151          ScheduledFuture h =
152              p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
153 <        Thread.sleep(SMALL_DELAY_MS);
153 >        delay(SMALL_DELAY_MS);
154          h.cancel(true);
155          int c = counter.count.get();
156          // By time scaling conventions, we must have at least
# Line 168 | Line 168 | public class ScheduledExecutorTest exten
168          RunnableCounter counter = new RunnableCounter();
169          ScheduledFuture h =
170              p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
171 <        Thread.sleep(SMALL_DELAY_MS);
171 >        delay(SMALL_DELAY_MS);
172          h.cancel(true);
173          int c = counter.count.get();
174          assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
# Line 240 | Line 240 | public class ScheduledExecutorTest exten
240      /**
241       * schedule callable throws RejectedExecutionException if shutdown
242       */
243 <     public void testSchedule3_RejectedExecutionException() throws InterruptedException {
244 <         ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
245 <         try {
243 >    public void testSchedule3_RejectedExecutionException() throws InterruptedException {
244 >        ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
245 >        try {
246              se.shutdown();
247              se.schedule(new NoOpCallable(),
248                          MEDIUM_DELAY_MS, MILLISECONDS);
# Line 250 | Line 250 | public class ScheduledExecutorTest exten
250          } catch (RejectedExecutionException success) {
251          } catch (SecurityException ok) {
252          }
253 <         joinPool(se);
253 >        joinPool(se);
254      }
255  
256      /**
# Line 331 | Line 331 | public class ScheduledExecutorTest exten
331              assertEquals(0, p.getCompletedTaskCount());
332              threadProceed.countDown();
333              threadDone.await();
334 <            Thread.sleep(SHORT_DELAY_MS);
334 >            delay(SHORT_DELAY_MS);
335              assertEquals(1, p.getCompletedTaskCount());
336          } finally {
337              joinPool(p);
# Line 587 | Line 587 | public class ScheduledExecutorTest exten
587      }
588  
589      /**
590 <     * purge removes cancelled tasks from the queue
590 >     * purge eventually removes cancelled tasks from the queue
591       */
592      public void testPurge() throws InterruptedException {
593          ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
594          ScheduledFuture[] tasks = new ScheduledFuture[5];
595 <        for (int i = 0; i < tasks.length; i++) {
596 <            tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
597 <        }
595 >        for (int i = 0; i < tasks.length; i++)
596 >            tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(),
597 >                                  LONG_DELAY_MS, MILLISECONDS);
598          try {
599              int max = tasks.length;
600              if (tasks[4].cancel(true)) --max;
601              if (tasks[3].cancel(true)) --max;
602              // There must eventually be an interference-free point at
603              // which purge will not fail. (At worst, when queue is empty.)
604 <            int k;
605 <            for (k = 0; k < SMALL_DELAY_MS; ++k) {
604 >            long startTime = System.nanoTime();
605 >            do {
606                  p.purge();
607                  long count = p.getTaskCount();
608 <                if (count >= 0 && count <= max)
609 <                    break;
610 <                Thread.sleep(1);
611 <            }
612 <            assertTrue(k < SMALL_DELAY_MS);
608 >                if (count == max)
609 >                    return;
610 >            } while (millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
611 >            fail("Purge failed to remove cancelled tasks");
612          } finally {
613              for (ScheduledFuture task : tasks)
614                  task.cancel(true);
# Line 620 | Line 619 | public class ScheduledExecutorTest exten
619      /**
620       * shutDownNow returns a list containing tasks that were not run
621       */
622 <    public void testShutDownNow() throws InterruptedException {
622 >    public void testShutdownNow() {
623          ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
624          for (int i = 0; i < 5; i++)
625 <            p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
626 <        List l;
625 >            p.schedule(new SmallPossiblyInterruptedRunnable(),
626 >                       LONG_DELAY_MS, MILLISECONDS);
627          try {
628 <            l = p.shutdownNow();
628 >            List<Runnable> l = p.shutdownNow();
629 >            assertTrue(p.isShutdown());
630 >            assertEquals(5, l.size());
631          } catch (SecurityException ok) {
632 <            return;
632 >            // Allowed in case test doesn't have privs
633 >        } finally {
634 >            joinPool(p);
635          }
633 –        assertTrue(p.isShutdown());
634 –        assertTrue(l.size() > 0 && l.size() <= 5);
635 –        joinPool(p);
636      }
637  
638      /**

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines