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.24 by jsr166, Fri May 27 16:26:29 2011 UTC vs.
Revision 1.29 by jsr166, Fri Jun 10 19:45:01 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 58 | Line 57 | public class ScheduledExecutorSubclassTe
57          protected <V> RunnableScheduledFuture<V> decorateTask(Callable<V> c, RunnableScheduledFuture<V> task) {
58              return new CustomTask<V>(task);
59          }
60 <        CustomExecutor(int corePoolSize) { super(corePoolSize);}
60 >        CustomExecutor(int corePoolSize) { super(corePoolSize); }
61          CustomExecutor(int corePoolSize, RejectedExecutionHandler handler) {
62              super(corePoolSize, handler);
63          }
# 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 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 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