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.23 by jsr166, Sat May 7 19:49:37 2011 UTC vs.
Revision 1.26 by jsr166, Sat May 28 15:33:19 2011 UTC

# 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 382 | Line 374 | public class ScheduledExecutorSubclassTe
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 523 | Line 519 | public class ScheduledExecutorSubclassTe
519          assertTrue(p.isShutdown());
520      }
521  
526 –
522      /**
523       * isTerminated is false before termination, true after
524       */
# Line 714 | Line 709 | public class ScheduledExecutorSubclassTe
709          }
710      }
711  
717 –
712      /**
713       * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
714       * delayed tasks are cancelled at shutdown
# 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
# Line 753 | Line 746 | public class ScheduledExecutorSubclassTe
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      /**

Diff Legend

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