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

Comparing jsr166/src/test/tck/ScheduledExecutorSubclassTest.java (file contents):
Revision 1.22 by jsr166, Sat May 7 19:34:51 2011 UTC vs.
Revision 1.28 by jsr166, Tue May 31 16:16:24 2011 UTC

# Line 8 | Line 8 | import junit.framework.*;
8   import java.util.*;
9   import java.util.concurrent.*;
10   import static java.util.concurrent.TimeUnit.MILLISECONDS;
11 < import java.util.concurrent.atomic.*;
11 > import java.util.concurrent.atomic.AtomicInteger;
12  
13   public class ScheduledExecutorSubclassTest extends JSR166TestCase {
14      public static void main(String[] args) {
# Line 48 | Line 48 | public class ScheduledExecutorSubclassTe
48          }
49      }
50  
51 –
51      public class CustomExecutor extends ScheduledThreadPoolExecutor {
52  
53          protected <V> RunnableScheduledFuture<V> decorateTask(Runnable r, RunnableScheduledFuture<V> task) {
# Line 73 | Line 72 | public class ScheduledExecutorSubclassTe
72  
73      }
74  
76 –
75      /**
76       * execute successfully executes a runnable
77       */
# Line 92 | Line 90 | public class ScheduledExecutorSubclassTe
90          }
91      }
92  
95 –
93      /**
94       * delayed schedule of callable successfully executes after delay
95       */
96      public void testSchedule1() throws Exception {
97          CustomExecutor p = new CustomExecutor(1);
98 <        final long t0 = System.nanoTime();
102 <        final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
98 >        final long startTime = System.nanoTime();
99          final CountDownLatch done = new CountDownLatch(1);
100          try {
101              Callable task = new CheckedCallable<Boolean>() {
102                  public Boolean realCall() {
103                      done.countDown();
104 <                    assertTrue(System.nanoTime() - t0 >= timeoutNanos);
104 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
105                      return Boolean.TRUE;
106                  }};
107 <            Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
108 <            assertEquals(Boolean.TRUE, f.get());
109 <            assertTrue(System.nanoTime() - t0 >= timeoutNanos);
107 >            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
108 >            assertSame(Boolean.TRUE, f.get());
109 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
110              assertTrue(done.await(0L, MILLISECONDS));
111          } finally {
112              joinPool(p);
# Line 122 | Line 118 | public class ScheduledExecutorSubclassTe
118       */
119      public void testSchedule3() throws Exception {
120          CustomExecutor p = new CustomExecutor(1);
121 <        final long t0 = System.nanoTime();
126 <        final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
121 >        final long startTime = System.nanoTime();
122          final CountDownLatch done = new CountDownLatch(1);
123          try {
124              Runnable task = new CheckedRunnable() {
125                  public void realRun() {
126                      done.countDown();
127 <                    assertTrue(System.nanoTime() - t0 >= timeoutNanos);
127 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
128                  }};
129 <            Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
130 <            assertNull(f.get());
131 <            assertTrue(System.nanoTime() - t0 >= timeoutNanos);
132 <            assertTrue(done.await(0L, MILLISECONDS));
129 >            Future f = p.schedule(task, timeoutMillis(), MILLISECONDS);
130 >            await(done);
131 >            assertNull(f.get(LONG_DELAY_MS, MILLISECONDS));
132 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
133          } finally {
134              joinPool(p);
135          }
# Line 145 | Line 140 | public class ScheduledExecutorSubclassTe
140       */
141      public void testSchedule4() throws InterruptedException {
142          CustomExecutor p = new CustomExecutor(1);
143 <        final long t0 = System.nanoTime();
149 <        final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
143 >        final long startTime = System.nanoTime();
144          final CountDownLatch done = new CountDownLatch(1);
145          try {
146              Runnable task = new CheckedRunnable() {
147                  public void realRun() {
148                      done.countDown();
149 <                    assertTrue(System.nanoTime() - t0 >= timeoutNanos);
149 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
150                  }};
151              ScheduledFuture f =
152 <                p.scheduleAtFixedRate(task, SHORT_DELAY_MS,
153 <                                      SHORT_DELAY_MS, MILLISECONDS);
154 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
155 <            assertTrue(System.nanoTime() - t0 >= timeoutNanos);
152 >                p.scheduleAtFixedRate(task, timeoutMillis(),
153 >                                      LONG_DELAY_MS, MILLISECONDS);
154 >            await(done);
155 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
156              f.cancel(true);
157          } finally {
158              joinPool(p);
# Line 170 | Line 164 | public class ScheduledExecutorSubclassTe
164       */
165      public void testSchedule5() throws InterruptedException {
166          CustomExecutor p = new CustomExecutor(1);
167 <        final long t0 = System.nanoTime();
174 <        final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
167 >        final long startTime = System.nanoTime();
168          final CountDownLatch done = new CountDownLatch(1);
169          try {
170              Runnable task = new CheckedRunnable() {
171                  public void realRun() {
172                      done.countDown();
173 <                    assertTrue(System.nanoTime() - t0 >= timeoutNanos);
173 >                    assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
174                  }};
175              ScheduledFuture f =
176 <                p.scheduleWithFixedDelay(task, SHORT_DELAY_MS,
177 <                                         SHORT_DELAY_MS, MILLISECONDS);
178 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
179 <            assertTrue(System.nanoTime() - t0 >= timeoutNanos);
176 >                p.scheduleWithFixedDelay(task, timeoutMillis(),
177 >                                         LONG_DELAY_MS, MILLISECONDS);
178 >            await(done);
179 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
180              f.cancel(true);
181          } finally {
182              joinPool(p);
# Line 229 | Line 222 | public class ScheduledExecutorSubclassTe
222          joinPool(p);
223      }
224  
232 –
225      /**
226       * execute(null) throws NPE
227       */
# Line 378 | Line 370 | public class ScheduledExecutorSubclassTe
370                      threadProceed.await();
371                      threadDone.countDown();
372                  }});
373 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
373 >            await(threadStarted);
374              assertEquals(0, p.getCompletedTaskCount());
375              threadProceed.countDown();
376              threadDone.await();
377 <            delay(SHORT_DELAY_MS);
378 <            assertEquals(1, p.getCompletedTaskCount());
377 >            long startTime = System.nanoTime();
378 >            while (p.getCompletedTaskCount() != 1) {
379 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
380 >                    fail("timed out");
381 >                Thread.yield();
382 >            }
383          } finally {
384              joinPool(p);
385          }
# Line 510 | Line 506 | public class ScheduledExecutorSubclassTe
506      }
507  
508      /**
509 <     * isShutDown is false before shutdown, true after
509 >     * isShutdown is false before shutdown, true after
510       */
511      public void testIsShutdown() {
512          CustomExecutor p = new CustomExecutor(1);
# Line 523 | Line 519 | public class ScheduledExecutorSubclassTe
519          assertTrue(p.isShutdown());
520      }
521  
526 –
522      /**
523       * isTerminated is false before termination, true after
524       */
# Line 667 | Line 662 | public class ScheduledExecutorSubclassTe
662      }
663  
664      /**
665 <     * shutDownNow returns a list containing tasks that were not run
665 >     * shutdownNow returns a list containing tasks that were not run
666       */
667 <    public void testShutDownNow() {
667 >    public void testShutdownNow() {
668          CustomExecutor p = new CustomExecutor(1);
669          for (int i = 0; i < 5; i++)
670              p.schedule(new SmallPossiblyInterruptedRunnable(),
# Line 689 | Line 684 | public class ScheduledExecutorSubclassTe
684       * In default setting, shutdown cancels periodic but not delayed
685       * tasks at shutdown
686       */
687 <    public void testShutDown1() throws InterruptedException {
687 >    public void testShutdown1() throws InterruptedException {
688          CustomExecutor p = new CustomExecutor(1);
689          assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
690          assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
# Line 714 | Line 709 | public class ScheduledExecutorSubclassTe
709          }
710      }
711  
717 –
712      /**
713       * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
714       * delayed tasks are cancelled at shutdown
715       */
716 <    public void testShutDown2() throws InterruptedException {
716 >    public void testShutdown2() throws InterruptedException {
717          CustomExecutor p = new CustomExecutor(1);
718          p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
719          assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
# Line 741 | Line 735 | public class ScheduledExecutorSubclassTe
735          }
736      }
737  
744 –
738      /**
739       * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
740       * periodic tasks are cancelled at shutdown
741       */
742 <    public void testShutDown3() throws InterruptedException {
742 >    public void testShutdown3() throws InterruptedException {
743          CustomExecutor p = new CustomExecutor(1);
744          assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
745          assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
746          p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
747          assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
748          assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
749 +        long initialDelay = LONG_DELAY_MS;
750          ScheduledFuture task =
751 <            p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
751 >            p.scheduleAtFixedRate(new NoOpRunnable(), initialDelay,
752 >                                  5, MILLISECONDS);
753          try { p.shutdown(); } catch (SecurityException ok) { return; }
754          assertTrue(p.isShutdown());
760 –        BlockingQueue q = p.getQueue();
755          assertTrue(p.getQueue().isEmpty());
756          assertTrue(task.isDone());
757          assertTrue(task.isCancelled());
758 <        assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
765 <        assertTrue(p.isTerminated());
758 >        joinPool(p);
759      }
760  
761      /**
762       * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
763       * periodic tasks are not cancelled at shutdown
764       */
765 <    public void testShutDown4() throws InterruptedException {
765 >    public void testShutdown4() throws InterruptedException {
766          CustomExecutor p = new CustomExecutor(1);
767          final CountDownLatch counter = new CountDownLatch(2);
768          try {
# Line 1211 | Line 1204 | public class ScheduledExecutorSubclassTe
1204              l.add(new StringTask());
1205              List<Future<String>> futures =
1206                  e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1207 <            assertEquals(3, futures.size());
1208 <            Iterator<Future<String>> it = futures.iterator();
1209 <            Future<String> f1 = it.next();
1210 <            Future<String> f2 = it.next();
1211 <            Future<String> f3 = it.next();
1219 <            assertTrue(f1.isDone());
1220 <            assertTrue(f2.isDone());
1221 <            assertTrue(f3.isDone());
1222 <            assertFalse(f1.isCancelled());
1223 <            assertTrue(f2.isCancelled());
1207 >            assertEquals(l.size(), futures.size());
1208 >            for (Future future : futures)
1209 >                assertTrue(future.isDone());
1210 >            assertFalse(futures.get(0).isCancelled());
1211 >            assertTrue(futures.get(1).isCancelled());
1212          } finally {
1213              joinPool(e);
1214          }

Diff Legend

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