ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ScheduledExecutorTest.java
Revision: 1.37
Committed: Tue Mar 15 19:47:07 2011 UTC (13 years, 1 month ago) by jsr166
Branch: MAIN
Changes since 1.36: +1 -1 lines
Log Message: 
Update Creative Commons license URL in legal notices

File Contents

# User Rev Content
1 dl 1.1 /*
2 dl 1.13 * Written by Doug Lea with assistance from members of JCP JSR-166
3     * Expert Group and released to the public domain, as explained at
4 jsr166 1.37 * http://creativecommons.org/publicdomain/zero/1.0/
5 jsr166 1.22 * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7 dl 1.1 */
8    
9     import junit.framework.*;
10     import java.util.*;
11     import java.util.concurrent.*;
12 jsr166 1.25 import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 dl 1.18 import java.util.concurrent.atomic.*;
14 dl 1.1
15 dl 1.4 public class ScheduledExecutorTest extends JSR166TestCase {
16 dl 1.1 public static void main(String[] args) {
17 jsr166 1.30 junit.textui.TestRunner.run(suite());
18 dl 1.1 }
19     public static Test suite() {
20 jsr166 1.26 return new TestSuite(ScheduledExecutorTest.class);
21 dl 1.1 }
22    
23    
24 dl 1.5 /**
25 dl 1.6 * execute successfully executes a runnable
26 dl 1.5 */
27 jsr166 1.25 public void testExecute() throws InterruptedException {
28 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
29     final CountDownLatch done = new CountDownLatch(1);
30     final Runnable task = new CheckedRunnable() {
31     public void realRun() {
32     done.countDown();
33     }};
34     try {
35     p.execute(task);
36     assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
37     } finally {
38     joinPool(p);
39     }
40 dl 1.1 }
41    
42 dl 1.6
43 dl 1.5 /**
44 dl 1.6 * delayed schedule of callable successfully executes after delay
45 dl 1.5 */
46 jsr166 1.25 public void testSchedule1() throws Exception {
47 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
48     final long t0 = System.nanoTime();
49     final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
50     final CountDownLatch done = new CountDownLatch(1);
51     try {
52     Callable task = new CheckedCallable<Boolean>() {
53     public Boolean realCall() {
54     done.countDown();
55     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
56     return Boolean.TRUE;
57     }};
58     Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
59     assertEquals(Boolean.TRUE, f.get());
60     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
61     assertTrue(done.await(0L, MILLISECONDS));
62     } finally {
63     joinPool(p);
64     }
65 dl 1.1 }
66    
67     /**
68 jsr166 1.32 * delayed schedule of runnable successfully executes after delay
69 dl 1.1 */
70 jsr166 1.33 public void testSchedule3() throws Exception {
71     ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
72     final long t0 = System.nanoTime();
73     final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
74     final CountDownLatch done = new CountDownLatch(1);
75     try {
76     Runnable task = new CheckedRunnable() {
77     public void realRun() {
78     done.countDown();
79     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
80     }};
81     Future f = p.schedule(task, SHORT_DELAY_MS, MILLISECONDS);
82     assertNull(f.get());
83     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
84     assertTrue(done.await(0L, MILLISECONDS));
85     } finally {
86     joinPool(p);
87     }
88 dl 1.1 }
89 jsr166 1.22
90 dl 1.1 /**
91 dl 1.6 * scheduleAtFixedRate executes runnable after given initial delay
92 dl 1.1 */
93 jsr166 1.33 public void testSchedule4() throws Exception {
94     ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
95     final long t0 = System.nanoTime();
96     final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
97     final CountDownLatch done = new CountDownLatch(1);
98     try {
99     Runnable task = new CheckedRunnable() {
100     public void realRun() {
101     done.countDown();
102     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
103     }};
104     ScheduledFuture f =
105     p.scheduleAtFixedRate(task, SHORT_DELAY_MS,
106     SHORT_DELAY_MS, MILLISECONDS);
107     assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
108     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
109     f.cancel(true);
110     } finally {
111     joinPool(p);
112     }
113 dl 1.18 }
114    
115 dl 1.6 /**
116     * scheduleWithFixedDelay executes runnable after given initial delay
117     */
118 jsr166 1.25 public void testSchedule5() throws InterruptedException {
119 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
120     final long t0 = System.nanoTime();
121     final long timeoutNanos = SHORT_DELAY_MS * 1000L * 1000L;
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);
128     }};
129     ScheduledFuture f =
130     p.scheduleWithFixedDelay(task, SHORT_DELAY_MS,
131     SHORT_DELAY_MS, MILLISECONDS);
132     assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
133     assertTrue(System.nanoTime() - t0 >= timeoutNanos);
134     f.cancel(true);
135     } finally {
136     joinPool(p);
137     }
138     }
139    
140     static class RunnableCounter implements Runnable {
141     AtomicInteger count = new AtomicInteger(0);
142     public void run() { count.getAndIncrement(); }
143 dl 1.1 }
144 jsr166 1.22
145 dl 1.6 /**
146 dl 1.18 * scheduleAtFixedRate executes series of tasks at given rate
147     */
148 jsr166 1.25 public void testFixedRateSequence() throws InterruptedException {
149 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
150 jsr166 1.25 RunnableCounter counter = new RunnableCounter();
151     ScheduledFuture h =
152 jsr166 1.33 p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
153 jsr166 1.25 Thread.sleep(SMALL_DELAY_MS);
154     h.cancel(true);
155     int c = counter.count.get();
156     // By time scaling conventions, we must have at least
157     // an execution per SHORT delay, but no more than one SHORT more
158     assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
159     assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
160 jsr166 1.33 joinPool(p);
161 dl 1.18 }
162    
163     /**
164     * scheduleWithFixedDelay executes series of tasks with given period
165     */
166 jsr166 1.25 public void testFixedDelaySequence() throws InterruptedException {
167 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
168 jsr166 1.25 RunnableCounter counter = new RunnableCounter();
169     ScheduledFuture h =
170 jsr166 1.33 p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
171 jsr166 1.25 Thread.sleep(SMALL_DELAY_MS);
172     h.cancel(true);
173     int c = counter.count.get();
174     assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
175     assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
176 jsr166 1.33 joinPool(p);
177 dl 1.18 }
178    
179    
180     /**
181 jsr166 1.32 * execute(null) throws NPE
182 dl 1.6 */
183 jsr166 1.25 public void testExecuteNull() throws InterruptedException {
184 dl 1.9 ScheduledThreadPoolExecutor se = null;
185 dl 1.6 try {
186 jsr166 1.26 se = new ScheduledThreadPoolExecutor(1);
187     se.execute(null);
188 dl 1.6 shouldThrow();
189 jsr166 1.26 } catch (NullPointerException success) {}
190 jsr166 1.22
191 jsr166 1.26 joinPool(se);
192 dl 1.6 }
193    
194     /**
195 jsr166 1.30 * schedule(null) throws NPE
196 dl 1.6 */
197 jsr166 1.25 public void testScheduleNull() throws InterruptedException {
198 dl 1.9 ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
199 jsr166 1.26 try {
200 dl 1.7 TrackedCallable callable = null;
201 jsr166 1.26 Future f = se.schedule(callable, SHORT_DELAY_MS, MILLISECONDS);
202 dl 1.6 shouldThrow();
203 jsr166 1.26 } catch (NullPointerException success) {}
204     joinPool(se);
205 dl 1.6 }
206 jsr166 1.22
207 dl 1.1 /**
208 dl 1.6 * execute throws RejectedExecutionException if shutdown
209 dl 1.1 */
210 jsr166 1.25 public void testSchedule1_RejectedExecutionException() throws InterruptedException {
211 dl 1.9 ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
212 dl 1.5 try {
213 dl 1.1 se.shutdown();
214 dl 1.4 se.schedule(new NoOpRunnable(),
215 jsr166 1.25 MEDIUM_DELAY_MS, MILLISECONDS);
216 dl 1.5 shouldThrow();
217 jsr166 1.24 } catch (RejectedExecutionException success) {
218 dl 1.17 } catch (SecurityException ok) {
219 dl 1.4 }
220 jsr166 1.22
221 dl 1.4 joinPool(se);
222 dl 1.1 }
223    
224     /**
225 dl 1.6 * schedule throws RejectedExecutionException if shutdown
226 dl 1.1 */
227 jsr166 1.25 public void testSchedule2_RejectedExecutionException() throws InterruptedException {
228 dl 1.9 ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
229 dl 1.5 try {
230 dl 1.1 se.shutdown();
231 dl 1.4 se.schedule(new NoOpCallable(),
232 jsr166 1.25 MEDIUM_DELAY_MS, MILLISECONDS);
233 dl 1.5 shouldThrow();
234 jsr166 1.24 } catch (RejectedExecutionException success) {
235 dl 1.17 } catch (SecurityException ok) {
236 dl 1.4 }
237     joinPool(se);
238 dl 1.1 }
239    
240     /**
241 dl 1.6 * schedule callable throws RejectedExecutionException if shutdown
242 dl 1.1 */
243 jsr166 1.25 public void testSchedule3_RejectedExecutionException() throws InterruptedException {
244 dl 1.9 ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
245 dl 1.5 try {
246 dl 1.1 se.shutdown();
247 dl 1.4 se.schedule(new NoOpCallable(),
248 jsr166 1.25 MEDIUM_DELAY_MS, MILLISECONDS);
249 dl 1.5 shouldThrow();
250 jsr166 1.24 } catch (RejectedExecutionException success) {
251 dl 1.17 } catch (SecurityException ok) {
252     }
253 dl 1.4 joinPool(se);
254 dl 1.1 }
255    
256     /**
257 jsr166 1.32 * scheduleAtFixedRate throws RejectedExecutionException if shutdown
258 dl 1.1 */
259 jsr166 1.25 public void testScheduleAtFixedRate1_RejectedExecutionException() throws InterruptedException {
260 dl 1.9 ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
261 dl 1.5 try {
262 dl 1.1 se.shutdown();
263 dl 1.4 se.scheduleAtFixedRate(new NoOpRunnable(),
264 jsr166 1.25 MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
265 dl 1.5 shouldThrow();
266 jsr166 1.24 } catch (RejectedExecutionException success) {
267 dl 1.17 } catch (SecurityException ok) {
268 jsr166 1.22 }
269 dl 1.4 joinPool(se);
270 dl 1.1 }
271 jsr166 1.22
272 dl 1.1 /**
273 dl 1.6 * scheduleWithFixedDelay throws RejectedExecutionException if shutdown
274 dl 1.1 */
275 jsr166 1.25 public void testScheduleWithFixedDelay1_RejectedExecutionException() throws InterruptedException {
276 dl 1.9 ScheduledThreadPoolExecutor se = new ScheduledThreadPoolExecutor(1);
277 dl 1.5 try {
278 dl 1.1 se.shutdown();
279 dl 1.4 se.scheduleWithFixedDelay(new NoOpRunnable(),
280 jsr166 1.25 MEDIUM_DELAY_MS, MEDIUM_DELAY_MS, MILLISECONDS);
281 dl 1.5 shouldThrow();
282 jsr166 1.24 } catch (RejectedExecutionException success) {
283 dl 1.17 } catch (SecurityException ok) {
284 jsr166 1.22 }
285 dl 1.4 joinPool(se);
286 dl 1.1 }
287    
288     /**
289 jsr166 1.32 * getActiveCount increases but doesn't overestimate, when a
290     * thread becomes active
291 dl 1.2 */
292 jsr166 1.25 public void testGetActiveCount() throws InterruptedException {
293 jsr166 1.33 final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
294     final CountDownLatch threadStarted = new CountDownLatch(1);
295     final CountDownLatch done = new CountDownLatch(1);
296     try {
297     assertEquals(0, p.getActiveCount());
298     p.execute(new CheckedRunnable() {
299     public void realRun() throws InterruptedException {
300     threadStarted.countDown();
301     assertEquals(1, p.getActiveCount());
302     done.await();
303     }});
304     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
305     assertEquals(1, p.getActiveCount());
306     } finally {
307     done.countDown();
308     joinPool(p);
309     }
310 dl 1.2 }
311 jsr166 1.22
312 dl 1.2 /**
313 jsr166 1.32 * getCompletedTaskCount increases, but doesn't overestimate,
314     * when tasks complete
315 dl 1.2 */
316 jsr166 1.25 public void testGetCompletedTaskCount() throws InterruptedException {
317 jsr166 1.33 final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(2);
318     final CountDownLatch threadStarted = new CountDownLatch(1);
319     final CountDownLatch threadProceed = new CountDownLatch(1);
320     final CountDownLatch threadDone = new CountDownLatch(1);
321     try {
322     assertEquals(0, p.getCompletedTaskCount());
323     p.execute(new CheckedRunnable() {
324     public void realRun() throws InterruptedException {
325     threadStarted.countDown();
326     assertEquals(0, p.getCompletedTaskCount());
327     threadProceed.await();
328     threadDone.countDown();
329     }});
330     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
331     assertEquals(0, p.getCompletedTaskCount());
332     threadProceed.countDown();
333     threadDone.await();
334     Thread.sleep(SHORT_DELAY_MS);
335     assertEquals(1, p.getCompletedTaskCount());
336     } finally {
337     joinPool(p);
338     }
339 dl 1.2 }
340 jsr166 1.22
341 dl 1.2 /**
342 jsr166 1.32 * getCorePoolSize returns size given in constructor if not otherwise set
343 dl 1.2 */
344 jsr166 1.25 public void testGetCorePoolSize() throws InterruptedException {
345 jsr166 1.33 ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
346     assertEquals(1, p.getCorePoolSize());
347     joinPool(p);
348 dl 1.2 }
349 jsr166 1.22
350 dl 1.2 /**
351 jsr166 1.32 * getLargestPoolSize increases, but doesn't overestimate, when
352     * multiple threads active
353 dl 1.2 */
354 jsr166 1.25 public void testGetLargestPoolSize() throws InterruptedException {
355 jsr166 1.33 final int THREADS = 3;
356     final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(THREADS);
357     final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
358     final CountDownLatch done = new CountDownLatch(1);
359     try {
360     assertEquals(0, p.getLargestPoolSize());
361     for (int i = 0; i < THREADS; i++)
362     p.execute(new CheckedRunnable() {
363     public void realRun() throws InterruptedException {
364     threadsStarted.countDown();
365     done.await();
366     assertEquals(THREADS, p.getLargestPoolSize());
367     }});
368     assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
369     assertEquals(THREADS, p.getLargestPoolSize());
370     } finally {
371     done.countDown();
372     joinPool(p);
373     assertEquals(THREADS, p.getLargestPoolSize());
374     }
375 dl 1.2 }
376 jsr166 1.22
377 dl 1.2 /**
378 jsr166 1.32 * getPoolSize increases, but doesn't overestimate, when threads
379     * become active
380 dl 1.2 */
381 jsr166 1.25 public void testGetPoolSize() throws InterruptedException {
382 jsr166 1.33 final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
383     final CountDownLatch threadStarted = new CountDownLatch(1);
384     final CountDownLatch done = new CountDownLatch(1);
385     try {
386     assertEquals(0, p.getPoolSize());
387     p.execute(new CheckedRunnable() {
388     public void realRun() throws InterruptedException {
389     threadStarted.countDown();
390     assertEquals(1, p.getPoolSize());
391     done.await();
392     }});
393     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
394     assertEquals(1, p.getPoolSize());
395     } finally {
396     done.countDown();
397     joinPool(p);
398     }
399 dl 1.2 }
400 jsr166 1.22
401 dl 1.2 /**
402 jsr166 1.32 * getTaskCount increases, but doesn't overestimate, when tasks
403     * submitted
404 dl 1.2 */
405 jsr166 1.25 public void testGetTaskCount() throws InterruptedException {
406 jsr166 1.33 final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
407     final CountDownLatch threadStarted = new CountDownLatch(1);
408     final CountDownLatch done = new CountDownLatch(1);
409     final int TASKS = 5;
410     try {
411     assertEquals(0, p.getTaskCount());
412     for (int i = 0; i < TASKS; i++)
413     p.execute(new CheckedRunnable() {
414     public void realRun() throws InterruptedException {
415     threadStarted.countDown();
416     done.await();
417     }});
418     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
419     assertEquals(TASKS, p.getTaskCount());
420     } finally {
421     done.countDown();
422     joinPool(p);
423     }
424 dl 1.2 }
425 dl 1.8
426 jsr166 1.22 /**
427 dl 1.8 * getThreadFactory returns factory in constructor if not set
428     */
429 jsr166 1.25 public void testGetThreadFactory() throws InterruptedException {
430 dl 1.8 ThreadFactory tf = new SimpleThreadFactory();
431 jsr166 1.26 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1, tf);
432 dl 1.8 assertSame(tf, p.getThreadFactory());
433     joinPool(p);
434     }
435    
436 jsr166 1.22 /**
437 dl 1.8 * setThreadFactory sets the thread factory returned by getThreadFactory
438     */
439 jsr166 1.25 public void testSetThreadFactory() throws InterruptedException {
440 dl 1.8 ThreadFactory tf = new SimpleThreadFactory();
441 jsr166 1.26 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
442 dl 1.8 p.setThreadFactory(tf);
443     assertSame(tf, p.getThreadFactory());
444     joinPool(p);
445     }
446    
447 jsr166 1.22 /**
448 dl 1.8 * setThreadFactory(null) throws NPE
449     */
450 jsr166 1.25 public void testSetThreadFactoryNull() throws InterruptedException {
451 jsr166 1.26 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
452 dl 1.8 try {
453     p.setThreadFactory(null);
454     shouldThrow();
455     } catch (NullPointerException success) {
456     } finally {
457     joinPool(p);
458     }
459     }
460 jsr166 1.22
461 dl 1.2 /**
462 jsr166 1.32 * isShutDown is false before shutdown, true after
463 dl 1.2 */
464 dl 1.5 public void testIsShutdown() {
465 jsr166 1.22
466 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
467 dl 1.2 try {
468 jsr166 1.33 assertFalse(p.isShutdown());
469 dl 1.2 }
470     finally {
471 jsr166 1.33 try { p.shutdown(); } catch (SecurityException ok) { return; }
472 dl 1.2 }
473 jsr166 1.33 assertTrue(p.isShutdown());
474 dl 1.2 }
475    
476 jsr166 1.22
477 dl 1.2 /**
478 jsr166 1.32 * isTerminated is false before termination, true after
479 dl 1.2 */
480 jsr166 1.25 public void testIsTerminated() throws InterruptedException {
481 jsr166 1.33 final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
482     final CountDownLatch threadStarted = new CountDownLatch(1);
483     final CountDownLatch done = new CountDownLatch(1);
484     assertFalse(p.isTerminated());
485     try {
486     p.execute(new CheckedRunnable() {
487     public void realRun() throws InterruptedException {
488 jsr166 1.36 assertFalse(p.isTerminated());
489 jsr166 1.33 threadStarted.countDown();
490     done.await();
491     }});
492     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
493 jsr166 1.36 assertFalse(p.isTerminating());
494 jsr166 1.33 done.countDown();
495 dl 1.2 } finally {
496 jsr166 1.33 try { p.shutdown(); } catch (SecurityException ok) { return; }
497 dl 1.2 }
498 jsr166 1.33 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
499     assertTrue(p.isTerminated());
500 dl 1.5 }
501    
502     /**
503 jsr166 1.32 * isTerminating is not true when running or when terminated
504 dl 1.5 */
505 jsr166 1.25 public void testIsTerminating() throws InterruptedException {
506 jsr166 1.33 final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
507     final CountDownLatch threadStarted = new CountDownLatch(1);
508     final CountDownLatch done = new CountDownLatch(1);
509     try {
510     assertFalse(p.isTerminating());
511     p.execute(new CheckedRunnable() {
512     public void realRun() throws InterruptedException {
513 jsr166 1.35 assertFalse(p.isTerminating());
514 jsr166 1.33 threadStarted.countDown();
515     done.await();
516     }});
517     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
518     assertFalse(p.isTerminating());
519     done.countDown();
520     } finally {
521     try { p.shutdown(); } catch (SecurityException ok) { return; }
522     }
523     assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
524     assertTrue(p.isTerminated());
525     assertFalse(p.isTerminating());
526 dl 1.2 }
527    
528     /**
529 dl 1.8 * getQueue returns the work queue, which contains queued tasks
530     */
531 jsr166 1.25 public void testGetQueue() throws InterruptedException {
532 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
533     final CountDownLatch threadStarted = new CountDownLatch(1);
534     final CountDownLatch done = new CountDownLatch(1);
535 dl 1.8 try {
536 jsr166 1.33 ScheduledFuture[] tasks = new ScheduledFuture[5];
537     for (int i = 0; i < tasks.length; i++) {
538     Runnable r = new CheckedRunnable() {
539     public void realRun() throws InterruptedException {
540     threadStarted.countDown();
541     done.await();
542     }};
543     tasks[i] = p.schedule(r, 1, MILLISECONDS);
544     }
545     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
546     BlockingQueue<Runnable> q = p.getQueue();
547     assertTrue(q.contains(tasks[tasks.length - 1]));
548 dl 1.8 assertFalse(q.contains(tasks[0]));
549     } finally {
550 jsr166 1.33 done.countDown();
551     joinPool(p);
552 dl 1.8 }
553     }
554    
555     /**
556     * remove(task) removes queued task, and fails to remove active task
557     */
558 jsr166 1.25 public void testRemove() throws InterruptedException {
559 jsr166 1.33 final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
560 dl 1.9 ScheduledFuture[] tasks = new ScheduledFuture[5];
561 jsr166 1.33 final CountDownLatch threadStarted = new CountDownLatch(1);
562     final CountDownLatch done = new CountDownLatch(1);
563 dl 1.8 try {
564 jsr166 1.33 for (int i = 0; i < tasks.length; i++) {
565     Runnable r = new CheckedRunnable() {
566     public void realRun() throws InterruptedException {
567     threadStarted.countDown();
568     done.await();
569     }};
570     tasks[i] = p.schedule(r, 1, MILLISECONDS);
571     }
572     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
573     BlockingQueue<Runnable> q = p.getQueue();
574     assertFalse(p.remove((Runnable)tasks[0]));
575 dl 1.8 assertTrue(q.contains((Runnable)tasks[4]));
576     assertTrue(q.contains((Runnable)tasks[3]));
577 jsr166 1.33 assertTrue(p.remove((Runnable)tasks[4]));
578     assertFalse(p.remove((Runnable)tasks[4]));
579 dl 1.8 assertFalse(q.contains((Runnable)tasks[4]));
580     assertTrue(q.contains((Runnable)tasks[3]));
581 jsr166 1.33 assertTrue(p.remove((Runnable)tasks[3]));
582 dl 1.8 assertFalse(q.contains((Runnable)tasks[3]));
583     } finally {
584 jsr166 1.33 done.countDown();
585     joinPool(p);
586 dl 1.8 }
587     }
588    
589     /**
590 jsr166 1.32 * purge removes cancelled tasks from the queue
591 dl 1.2 */
592 jsr166 1.25 public void testPurge() throws InterruptedException {
593 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
594 dl 1.9 ScheduledFuture[] tasks = new ScheduledFuture[5];
595 jsr166 1.33 for (int i = 0; i < tasks.length; i++) {
596     tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
597 dl 1.19 }
598     try {
599 jsr166 1.33 int max = tasks.length;
600 dl 1.19 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) {
606 jsr166 1.33 p.purge();
607     long count = p.getTaskCount();
608 dl 1.19 if (count >= 0 && count <= max)
609     break;
610     Thread.sleep(1);
611     }
612     assertTrue(k < SMALL_DELAY_MS);
613     } finally {
614 jsr166 1.33 for (ScheduledFuture task : tasks)
615     task.cancel(true);
616     joinPool(p);
617 dl 1.2 }
618     }
619    
620     /**
621 jsr166 1.32 * shutDownNow returns a list containing tasks that were not run
622 dl 1.2 */
623 jsr166 1.25 public void testShutDownNow() throws InterruptedException {
624 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
625 jsr166 1.23 for (int i = 0; i < 5; i++)
626 jsr166 1.33 p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
627 dl 1.17 List l;
628     try {
629 jsr166 1.33 l = p.shutdownNow();
630 jsr166 1.22 } catch (SecurityException ok) {
631 dl 1.17 return;
632     }
633 jsr166 1.33 assertTrue(p.isShutdown());
634 jsr166 1.26 assertTrue(l.size() > 0 && l.size() <= 5);
635 jsr166 1.33 joinPool(p);
636 dl 1.2 }
637    
638 dl 1.5 /**
639 dl 1.6 * In default setting, shutdown cancels periodic but not delayed
640     * tasks at shutdown
641 dl 1.5 */
642 jsr166 1.25 public void testShutDown1() throws InterruptedException {
643 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
644     assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
645     assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
646 jsr166 1.22
647 jsr166 1.25 ScheduledFuture[] tasks = new ScheduledFuture[5];
648 jsr166 1.33 for (int i = 0; i < tasks.length; i++)
649     tasks[i] = p.schedule(new NoOpRunnable(),
650     SHORT_DELAY_MS, MILLISECONDS);
651     try { p.shutdown(); } catch (SecurityException ok) { return; }
652     BlockingQueue<Runnable> q = p.getQueue();
653     for (ScheduledFuture task : tasks) {
654     assertFalse(task.isDone());
655     assertFalse(task.isCancelled());
656     assertTrue(q.contains(task));
657 jsr166 1.25 }
658 jsr166 1.33 assertTrue(p.isShutdown());
659     assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
660     assertTrue(p.isTerminated());
661     for (ScheduledFuture task : tasks) {
662     assertTrue(task.isDone());
663     assertFalse(task.isCancelled());
664 dl 1.2 }
665     }
666    
667    
668 dl 1.5 /**
669 dl 1.6 * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
670     * delayed tasks are cancelled at shutdown
671 dl 1.5 */
672 jsr166 1.25 public void testShutDown2() throws InterruptedException {
673 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
674     p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
675 jsr166 1.34 assertFalse(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
676     assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
677 jsr166 1.25 ScheduledFuture[] tasks = new ScheduledFuture[5];
678 jsr166 1.33 for (int i = 0; i < tasks.length; i++)
679     tasks[i] = p.schedule(new NoOpRunnable(),
680     SHORT_DELAY_MS, MILLISECONDS);
681     BlockingQueue q = p.getQueue();
682     assertEquals(tasks.length, q.size());
683     try { p.shutdown(); } catch (SecurityException ok) { return; }
684     assertTrue(p.isShutdown());
685 jsr166 1.25 assertTrue(q.isEmpty());
686 jsr166 1.33 assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
687     assertTrue(p.isTerminated());
688     for (ScheduledFuture task : tasks) {
689     assertTrue(task.isDone());
690     assertTrue(task.isCancelled());
691     }
692 dl 1.2 }
693    
694 dl 1.5 /**
695 dl 1.6 * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
696 jsr166 1.33 * periodic tasks are cancelled at shutdown
697 dl 1.5 */
698 jsr166 1.25 public void testShutDown3() throws InterruptedException {
699 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
700 jsr166 1.34 assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
701     assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
702 jsr166 1.33 p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
703 jsr166 1.34 assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
704     assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
705 jsr166 1.25 ScheduledFuture task =
706 jsr166 1.33 p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
707     try { p.shutdown(); } catch (SecurityException ok) { return; }
708     assertTrue(p.isShutdown());
709     BlockingQueue q = p.getQueue();
710     assertTrue(p.getQueue().isEmpty());
711     assertTrue(task.isDone());
712     assertTrue(task.isCancelled());
713     assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
714     assertTrue(p.isTerminated());
715 dl 1.2 }
716    
717 dl 1.5 /**
718 dl 1.6 * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
719 jsr166 1.33 * periodic tasks are not cancelled at shutdown
720 dl 1.5 */
721 jsr166 1.25 public void testShutDown4() throws InterruptedException {
722 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
723     final CountDownLatch counter = new CountDownLatch(2);
724 dl 1.2 try {
725 jsr166 1.34 p.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
726     assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
727     assertTrue(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
728 jsr166 1.33 final Runnable r = new CheckedRunnable() {
729     public void realRun() {
730     counter.countDown();
731     }};
732 dl 1.9 ScheduledFuture task =
733 jsr166 1.33 p.scheduleAtFixedRate(r, 1, 1, MILLISECONDS);
734     assertFalse(task.isDone());
735 dl 1.2 assertFalse(task.isCancelled());
736 jsr166 1.33 try { p.shutdown(); } catch (SecurityException ok) { return; }
737 dl 1.2 assertFalse(task.isCancelled());
738 jsr166 1.33 assertFalse(p.isTerminated());
739     assertTrue(p.isShutdown());
740     assertTrue(counter.await(SMALL_DELAY_MS, MILLISECONDS));
741 dl 1.2 assertFalse(task.isCancelled());
742 jsr166 1.33 assertTrue(task.cancel(false));
743 dl 1.15 assertTrue(task.isDone());
744 jsr166 1.33 assertTrue(task.isCancelled());
745     assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
746     assertTrue(p.isTerminated());
747 dl 1.2 }
748 jsr166 1.22 finally {
749 jsr166 1.33 joinPool(p);
750 dl 1.2 }
751 dl 1.1 }
752    
753 dl 1.10 /**
754     * completed submit of callable returns result
755     */
756 jsr166 1.25 public void testSubmitCallable() throws Exception {
757 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
758     try {
759     Future<String> future = e.submit(new StringTask());
760     String result = future.get();
761     assertSame(TEST_STRING, result);
762     } finally {
763     joinPool(e);
764     }
765     }
766    
767     /**
768     * completed submit of runnable returns successfully
769     */
770 jsr166 1.25 public void testSubmitRunnable() throws Exception {
771 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
772     try {
773     Future<?> future = e.submit(new NoOpRunnable());
774     future.get();
775     assertTrue(future.isDone());
776     } finally {
777     joinPool(e);
778     }
779     }
780    
781     /**
782     * completed submit of (runnable, result) returns result
783     */
784 jsr166 1.25 public void testSubmitRunnable2() throws Exception {
785 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
786     try {
787     Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
788     String result = future.get();
789     assertSame(TEST_STRING, result);
790     } finally {
791     joinPool(e);
792     }
793     }
794    
795     /**
796     * invokeAny(null) throws NPE
797     */
798 jsr166 1.25 public void testInvokeAny1() throws Exception {
799 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
800     try {
801     e.invokeAny(null);
802 jsr166 1.25 shouldThrow();
803 dl 1.10 } catch (NullPointerException success) {
804     } finally {
805     joinPool(e);
806     }
807     }
808    
809     /**
810     * invokeAny(empty collection) throws IAE
811     */
812 jsr166 1.25 public void testInvokeAny2() throws Exception {
813 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
814     try {
815     e.invokeAny(new ArrayList<Callable<String>>());
816 jsr166 1.25 shouldThrow();
817 dl 1.10 } catch (IllegalArgumentException success) {
818     } finally {
819     joinPool(e);
820     }
821     }
822    
823     /**
824     * invokeAny(c) throws NPE if c has null elements
825     */
826 jsr166 1.25 public void testInvokeAny3() throws Exception {
827 jsr166 1.29 CountDownLatch latch = new CountDownLatch(1);
828 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
829 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
830     l.add(latchAwaitingStringTask(latch));
831     l.add(null);
832 dl 1.10 try {
833     e.invokeAny(l);
834 jsr166 1.25 shouldThrow();
835 dl 1.10 } catch (NullPointerException success) {
836     } finally {
837 jsr166 1.25 latch.countDown();
838 dl 1.10 joinPool(e);
839     }
840     }
841    
842     /**
843     * invokeAny(c) throws ExecutionException if no task completes
844     */
845 jsr166 1.25 public void testInvokeAny4() throws Exception {
846 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
847 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
848     l.add(new NPETask());
849 dl 1.10 try {
850     e.invokeAny(l);
851 jsr166 1.25 shouldThrow();
852 dl 1.10 } catch (ExecutionException success) {
853 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
854 dl 1.10 } finally {
855     joinPool(e);
856     }
857     }
858    
859     /**
860     * invokeAny(c) returns result of some task
861     */
862 jsr166 1.25 public void testInvokeAny5() throws Exception {
863 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
864     try {
865 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
866 dl 1.10 l.add(new StringTask());
867     l.add(new StringTask());
868     String result = e.invokeAny(l);
869     assertSame(TEST_STRING, result);
870     } finally {
871     joinPool(e);
872     }
873     }
874    
875     /**
876     * invokeAll(null) throws NPE
877     */
878 jsr166 1.25 public void testInvokeAll1() throws Exception {
879 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
880     try {
881     e.invokeAll(null);
882 jsr166 1.25 shouldThrow();
883 dl 1.10 } catch (NullPointerException success) {
884     } finally {
885     joinPool(e);
886     }
887     }
888    
889     /**
890     * invokeAll(empty collection) returns empty collection
891     */
892 jsr166 1.25 public void testInvokeAll2() throws Exception {
893 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
894     try {
895     List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
896     assertTrue(r.isEmpty());
897     } finally {
898     joinPool(e);
899     }
900     }
901    
902     /**
903     * invokeAll(c) throws NPE if c has null elements
904     */
905 jsr166 1.25 public void testInvokeAll3() throws Exception {
906 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
907 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
908     l.add(new StringTask());
909     l.add(null);
910 dl 1.10 try {
911     e.invokeAll(l);
912 jsr166 1.25 shouldThrow();
913 dl 1.10 } catch (NullPointerException success) {
914     } finally {
915     joinPool(e);
916     }
917     }
918    
919     /**
920     * get of invokeAll(c) throws exception on failed task
921     */
922 jsr166 1.25 public void testInvokeAll4() throws Exception {
923 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
924 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
925     l.add(new NPETask());
926     List<Future<String>> futures = e.invokeAll(l);
927     assertEquals(1, futures.size());
928 dl 1.10 try {
929 jsr166 1.29 futures.get(0).get();
930 jsr166 1.25 shouldThrow();
931 jsr166 1.23 } catch (ExecutionException success) {
932 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
933 dl 1.10 } finally {
934     joinPool(e);
935     }
936     }
937    
938     /**
939     * invokeAll(c) returns results of all completed tasks
940     */
941 jsr166 1.25 public void testInvokeAll5() throws Exception {
942 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
943     try {
944 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
945 dl 1.10 l.add(new StringTask());
946     l.add(new StringTask());
947 jsr166 1.29 List<Future<String>> futures = e.invokeAll(l);
948     assertEquals(2, futures.size());
949     for (Future<String> future : futures)
950 jsr166 1.25 assertSame(TEST_STRING, future.get());
951 dl 1.10 } finally {
952     joinPool(e);
953     }
954     }
955    
956 dl 1.11 /**
957     * timed invokeAny(null) throws NPE
958     */
959 jsr166 1.25 public void testTimedInvokeAny1() throws Exception {
960 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
961     try {
962 jsr166 1.25 e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
963     shouldThrow();
964 dl 1.11 } catch (NullPointerException success) {
965     } finally {
966     joinPool(e);
967     }
968     }
969    
970     /**
971     * timed invokeAny(,,null) throws NPE
972     */
973 jsr166 1.25 public void testTimedInvokeAnyNullTimeUnit() throws Exception {
974 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
975 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
976     l.add(new StringTask());
977 dl 1.11 try {
978     e.invokeAny(l, MEDIUM_DELAY_MS, null);
979 jsr166 1.25 shouldThrow();
980 dl 1.11 } catch (NullPointerException success) {
981     } finally {
982     joinPool(e);
983     }
984     }
985    
986     /**
987     * timed invokeAny(empty collection) throws IAE
988     */
989 jsr166 1.25 public void testTimedInvokeAny2() throws Exception {
990 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
991     try {
992 jsr166 1.25 e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
993     shouldThrow();
994 dl 1.11 } catch (IllegalArgumentException success) {
995     } finally {
996     joinPool(e);
997     }
998     }
999    
1000     /**
1001     * timed invokeAny(c) throws NPE if c has null elements
1002     */
1003 jsr166 1.25 public void testTimedInvokeAny3() throws Exception {
1004 jsr166 1.29 CountDownLatch latch = new CountDownLatch(1);
1005 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1006 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1007     l.add(latchAwaitingStringTask(latch));
1008     l.add(null);
1009 dl 1.11 try {
1010 jsr166 1.25 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1011     shouldThrow();
1012 dl 1.11 } catch (NullPointerException success) {
1013     } finally {
1014 jsr166 1.25 latch.countDown();
1015 dl 1.11 joinPool(e);
1016     }
1017     }
1018    
1019     /**
1020     * timed invokeAny(c) throws ExecutionException if no task completes
1021     */
1022 jsr166 1.25 public void testTimedInvokeAny4() throws Exception {
1023 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1024 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1025     l.add(new NPETask());
1026 dl 1.11 try {
1027 jsr166 1.25 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1028     shouldThrow();
1029 jsr166 1.23 } catch (ExecutionException success) {
1030 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
1031 dl 1.11 } finally {
1032     joinPool(e);
1033     }
1034     }
1035    
1036     /**
1037     * timed invokeAny(c) returns result of some task
1038     */
1039 jsr166 1.25 public void testTimedInvokeAny5() throws Exception {
1040 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1041     try {
1042 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1043 dl 1.11 l.add(new StringTask());
1044     l.add(new StringTask());
1045 jsr166 1.25 String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1046 dl 1.11 assertSame(TEST_STRING, result);
1047     } finally {
1048     joinPool(e);
1049     }
1050     }
1051    
1052     /**
1053     * timed invokeAll(null) throws NPE
1054     */
1055 jsr166 1.25 public void testTimedInvokeAll1() throws Exception {
1056 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1057     try {
1058 jsr166 1.25 e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1059     shouldThrow();
1060 dl 1.11 } catch (NullPointerException success) {
1061     } finally {
1062     joinPool(e);
1063     }
1064     }
1065    
1066     /**
1067     * timed invokeAll(,,null) throws NPE
1068     */
1069 jsr166 1.25 public void testTimedInvokeAllNullTimeUnit() throws Exception {
1070 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1071 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1072     l.add(new StringTask());
1073 dl 1.11 try {
1074     e.invokeAll(l, MEDIUM_DELAY_MS, null);
1075 jsr166 1.25 shouldThrow();
1076 dl 1.11 } catch (NullPointerException success) {
1077     } finally {
1078     joinPool(e);
1079     }
1080     }
1081    
1082     /**
1083     * timed invokeAll(empty collection) returns empty collection
1084     */
1085 jsr166 1.25 public void testTimedInvokeAll2() throws Exception {
1086 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1087     try {
1088 jsr166 1.25 List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1089 dl 1.11 assertTrue(r.isEmpty());
1090     } finally {
1091     joinPool(e);
1092     }
1093     }
1094    
1095     /**
1096     * timed invokeAll(c) throws NPE if c has null elements
1097     */
1098 jsr166 1.25 public void testTimedInvokeAll3() throws Exception {
1099 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1100 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1101     l.add(new StringTask());
1102     l.add(null);
1103 dl 1.11 try {
1104 jsr166 1.25 e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1105     shouldThrow();
1106 dl 1.11 } catch (NullPointerException success) {
1107     } finally {
1108     joinPool(e);
1109     }
1110     }
1111    
1112     /**
1113     * get of element of invokeAll(c) throws exception on failed task
1114     */
1115 jsr166 1.25 public void testTimedInvokeAll4() throws Exception {
1116 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1117 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1118     l.add(new NPETask());
1119     List<Future<String>> futures =
1120     e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1121     assertEquals(1, futures.size());
1122 dl 1.11 try {
1123 jsr166 1.29 futures.get(0).get();
1124 jsr166 1.25 shouldThrow();
1125 jsr166 1.23 } catch (ExecutionException success) {
1126 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
1127 dl 1.11 } finally {
1128     joinPool(e);
1129     }
1130     }
1131    
1132     /**
1133     * timed invokeAll(c) returns results of all completed tasks
1134     */
1135 jsr166 1.25 public void testTimedInvokeAll5() throws Exception {
1136 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1137     try {
1138 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1139 dl 1.11 l.add(new StringTask());
1140     l.add(new StringTask());
1141 jsr166 1.29 List<Future<String>> futures =
1142     e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1143     assertEquals(2, futures.size());
1144     for (Future<String> future : futures)
1145 jsr166 1.25 assertSame(TEST_STRING, future.get());
1146 dl 1.11 } finally {
1147     joinPool(e);
1148     }
1149     }
1150    
1151     /**
1152     * timed invokeAll(c) cancels tasks not completed by timeout
1153     */
1154 jsr166 1.25 public void testTimedInvokeAll6() throws Exception {
1155 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1156     try {
1157 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1158 dl 1.11 l.add(new StringTask());
1159 dl 1.12 l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1160 dl 1.14 l.add(new StringTask());
1161 jsr166 1.29 List<Future<String>> futures =
1162     e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1163     assertEquals(3, futures.size());
1164     Iterator<Future<String>> it = futures.iterator();
1165 dl 1.11 Future<String> f1 = it.next();
1166     Future<String> f2 = it.next();
1167 dl 1.14 Future<String> f3 = it.next();
1168 dl 1.11 assertTrue(f1.isDone());
1169 dl 1.14 assertTrue(f2.isDone());
1170     assertTrue(f3.isDone());
1171 dl 1.11 assertFalse(f1.isCancelled());
1172     assertTrue(f2.isCancelled());
1173     } finally {
1174     joinPool(e);
1175     }
1176     }
1177    
1178 dl 1.10
1179 dl 1.1 }