ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ScheduledExecutorTest.java
Revision: 1.33
Committed: Mon Oct 11 07:21:32 2010 UTC (13 years, 6 months ago) by jsr166
Branch: MAIN
Changes since 1.32: +349 -192 lines
Log Message: 
remove timing dependencies and optimize runtimes; descriptions of testShutdown3 and testShutdown4 were reversed; testShutDown2 never tested its assertion

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     * http://creativecommons.org/licenses/publicdomain
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     threadStarted.countDown();
489     assertFalse(p.isTerminated());
490     done.await();
491     }});
492     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
493     done.countDown();
494 dl 1.2 } finally {
495 jsr166 1.33 try { p.shutdown(); } catch (SecurityException ok) { return; }
496 dl 1.2 }
497 jsr166 1.33 assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
498     assertTrue(p.isTerminated());
499 dl 1.5 }
500    
501     /**
502 jsr166 1.32 * isTerminating is not true when running or when terminated
503 dl 1.5 */
504 jsr166 1.25 public void testIsTerminating() throws InterruptedException {
505 jsr166 1.33 final ThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
506     final CountDownLatch threadStarted = new CountDownLatch(1);
507     final CountDownLatch done = new CountDownLatch(1);
508     try {
509     assertFalse(p.isTerminating());
510     p.execute(new CheckedRunnable() {
511     public void realRun() throws InterruptedException {
512     threadStarted.countDown();
513     assertFalse(p.isTerminating());
514     done.await();
515     }});
516     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
517     assertFalse(p.isTerminating());
518     done.countDown();
519     } finally {
520     try { p.shutdown(); } catch (SecurityException ok) { return; }
521     }
522     assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
523     assertTrue(p.isTerminated());
524     assertFalse(p.isTerminating());
525 dl 1.2 }
526    
527     /**
528 dl 1.8 * getQueue returns the work queue, which contains queued tasks
529     */
530 jsr166 1.25 public void testGetQueue() throws InterruptedException {
531 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
532     final CountDownLatch threadStarted = new CountDownLatch(1);
533     final CountDownLatch done = new CountDownLatch(1);
534 dl 1.8 try {
535 jsr166 1.33 ScheduledFuture[] tasks = new ScheduledFuture[5];
536     for (int i = 0; i < tasks.length; i++) {
537     Runnable r = new CheckedRunnable() {
538     public void realRun() throws InterruptedException {
539     threadStarted.countDown();
540     done.await();
541     }};
542     tasks[i] = p.schedule(r, 1, MILLISECONDS);
543     }
544     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
545     BlockingQueue<Runnable> q = p.getQueue();
546     assertTrue(q.contains(tasks[tasks.length - 1]));
547 dl 1.8 assertFalse(q.contains(tasks[0]));
548     } finally {
549 jsr166 1.33 done.countDown();
550     joinPool(p);
551 dl 1.8 }
552     }
553    
554     /**
555     * remove(task) removes queued task, and fails to remove active task
556     */
557 jsr166 1.25 public void testRemove() throws InterruptedException {
558 jsr166 1.33 final ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
559 dl 1.9 ScheduledFuture[] tasks = new ScheduledFuture[5];
560 jsr166 1.33 final CountDownLatch threadStarted = new CountDownLatch(1);
561     final CountDownLatch done = new CountDownLatch(1);
562 dl 1.8 try {
563 jsr166 1.33 for (int i = 0; i < tasks.length; i++) {
564     Runnable r = new CheckedRunnable() {
565     public void realRun() throws InterruptedException {
566     threadStarted.countDown();
567     done.await();
568     }};
569     tasks[i] = p.schedule(r, 1, MILLISECONDS);
570     }
571     assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
572     BlockingQueue<Runnable> q = p.getQueue();
573     assertFalse(p.remove((Runnable)tasks[0]));
574 dl 1.8 assertTrue(q.contains((Runnable)tasks[4]));
575     assertTrue(q.contains((Runnable)tasks[3]));
576 jsr166 1.33 assertTrue(p.remove((Runnable)tasks[4]));
577     assertFalse(p.remove((Runnable)tasks[4]));
578 dl 1.8 assertFalse(q.contains((Runnable)tasks[4]));
579     assertTrue(q.contains((Runnable)tasks[3]));
580 jsr166 1.33 assertTrue(p.remove((Runnable)tasks[3]));
581 dl 1.8 assertFalse(q.contains((Runnable)tasks[3]));
582     } finally {
583 jsr166 1.33 done.countDown();
584     joinPool(p);
585 dl 1.8 }
586     }
587    
588     /**
589 jsr166 1.32 * purge removes cancelled tasks from the queue
590 dl 1.2 */
591 jsr166 1.25 public void testPurge() throws InterruptedException {
592 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
593 dl 1.9 ScheduledFuture[] tasks = new ScheduledFuture[5];
594 jsr166 1.33 for (int i = 0; i < tasks.length; i++) {
595     tasks[i] = p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
596 dl 1.19 }
597     try {
598 jsr166 1.33 int max = tasks.length;
599 dl 1.19 if (tasks[4].cancel(true)) --max;
600     if (tasks[3].cancel(true)) --max;
601     // There must eventually be an interference-free point at
602     // which purge will not fail. (At worst, when queue is empty.)
603     int k;
604     for (k = 0; k < SMALL_DELAY_MS; ++k) {
605 jsr166 1.33 p.purge();
606     long count = p.getTaskCount();
607 dl 1.19 if (count >= 0 && count <= max)
608     break;
609     Thread.sleep(1);
610     }
611     assertTrue(k < SMALL_DELAY_MS);
612     } finally {
613 jsr166 1.33 for (ScheduledFuture task : tasks)
614     task.cancel(true);
615     joinPool(p);
616 dl 1.2 }
617     }
618    
619     /**
620 jsr166 1.32 * shutDownNow returns a list containing tasks that were not run
621 dl 1.2 */
622 jsr166 1.25 public void testShutDownNow() throws InterruptedException {
623 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
624 jsr166 1.23 for (int i = 0; i < 5; i++)
625 jsr166 1.33 p.schedule(new SmallPossiblyInterruptedRunnable(), SHORT_DELAY_MS, MILLISECONDS);
626 dl 1.17 List l;
627     try {
628 jsr166 1.33 l = p.shutdownNow();
629 jsr166 1.22 } catch (SecurityException ok) {
630 dl 1.17 return;
631     }
632 jsr166 1.33 assertTrue(p.isShutdown());
633 jsr166 1.26 assertTrue(l.size() > 0 && l.size() <= 5);
634 jsr166 1.33 joinPool(p);
635 dl 1.2 }
636    
637 dl 1.5 /**
638 dl 1.6 * In default setting, shutdown cancels periodic but not delayed
639     * tasks at shutdown
640 dl 1.5 */
641 jsr166 1.25 public void testShutDown1() throws InterruptedException {
642 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
643     assertTrue(p.getExecuteExistingDelayedTasksAfterShutdownPolicy());
644     assertFalse(p.getContinueExistingPeriodicTasksAfterShutdownPolicy());
645 jsr166 1.22
646 jsr166 1.25 ScheduledFuture[] tasks = new ScheduledFuture[5];
647 jsr166 1.33 for (int i = 0; i < tasks.length; i++)
648     tasks[i] = p.schedule(new NoOpRunnable(),
649     SHORT_DELAY_MS, MILLISECONDS);
650     try { p.shutdown(); } catch (SecurityException ok) { return; }
651     BlockingQueue<Runnable> q = p.getQueue();
652     for (ScheduledFuture task : tasks) {
653     assertFalse(task.isDone());
654     assertFalse(task.isCancelled());
655     assertTrue(q.contains(task));
656 jsr166 1.25 }
657 jsr166 1.33 assertTrue(p.isShutdown());
658     assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
659     assertTrue(p.isTerminated());
660     for (ScheduledFuture task : tasks) {
661     assertTrue(task.isDone());
662     assertFalse(task.isCancelled());
663 dl 1.2 }
664     }
665    
666    
667 dl 1.5 /**
668 dl 1.6 * If setExecuteExistingDelayedTasksAfterShutdownPolicy is false,
669     * delayed tasks are cancelled at shutdown
670 dl 1.5 */
671 jsr166 1.25 public void testShutDown2() throws InterruptedException {
672 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
673     p.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
674 jsr166 1.25 ScheduledFuture[] tasks = new ScheduledFuture[5];
675 jsr166 1.33 for (int i = 0; i < tasks.length; i++)
676     tasks[i] = p.schedule(new NoOpRunnable(),
677     SHORT_DELAY_MS, MILLISECONDS);
678     BlockingQueue q = p.getQueue();
679     assertEquals(tasks.length, q.size());
680     try { p.shutdown(); } catch (SecurityException ok) { return; }
681     assertTrue(p.isShutdown());
682 jsr166 1.25 assertTrue(q.isEmpty());
683 jsr166 1.33 assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
684     assertTrue(p.isTerminated());
685     for (ScheduledFuture task : tasks) {
686     assertTrue(task.isDone());
687     assertTrue(task.isCancelled());
688     }
689 dl 1.2 }
690    
691 dl 1.5 /**
692 dl 1.6 * If setContinueExistingPeriodicTasksAfterShutdownPolicy is set false,
693 jsr166 1.33 * periodic tasks are cancelled at shutdown
694 dl 1.5 */
695 jsr166 1.25 public void testShutDown3() throws InterruptedException {
696 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
697     p.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
698 jsr166 1.25 ScheduledFuture task =
699 jsr166 1.33 p.scheduleAtFixedRate(new NoOpRunnable(), 5, 5, MILLISECONDS);
700     try { p.shutdown(); } catch (SecurityException ok) { return; }
701     assertTrue(p.isShutdown());
702     BlockingQueue q = p.getQueue();
703     assertTrue(p.getQueue().isEmpty());
704     assertTrue(task.isDone());
705     assertTrue(task.isCancelled());
706     assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
707     assertTrue(p.isTerminated());
708 dl 1.2 }
709    
710 dl 1.5 /**
711 dl 1.6 * if setContinueExistingPeriodicTasksAfterShutdownPolicy is true,
712 jsr166 1.33 * periodic tasks are not cancelled at shutdown
713 dl 1.5 */
714 jsr166 1.25 public void testShutDown4() throws InterruptedException {
715 jsr166 1.33 ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
716     p.setContinueExistingPeriodicTasksAfterShutdownPolicy(true);
717     final CountDownLatch counter = new CountDownLatch(2);
718 dl 1.2 try {
719 jsr166 1.33 final Runnable r = new CheckedRunnable() {
720     public void realRun() {
721     counter.countDown();
722     }};
723 dl 1.9 ScheduledFuture task =
724 jsr166 1.33 p.scheduleAtFixedRate(r, 1, 1, MILLISECONDS);
725     assertFalse(task.isDone());
726 dl 1.2 assertFalse(task.isCancelled());
727 jsr166 1.33 try { p.shutdown(); } catch (SecurityException ok) { return; }
728 dl 1.2 assertFalse(task.isCancelled());
729 jsr166 1.33 assertFalse(p.isTerminated());
730     assertTrue(p.isShutdown());
731     assertTrue(counter.await(SMALL_DELAY_MS, MILLISECONDS));
732 dl 1.2 assertFalse(task.isCancelled());
733 jsr166 1.33 assertTrue(task.cancel(false));
734 dl 1.15 assertTrue(task.isDone());
735 jsr166 1.33 assertTrue(task.isCancelled());
736     assertTrue(p.awaitTermination(SMALL_DELAY_MS, MILLISECONDS));
737     assertTrue(p.isTerminated());
738 dl 1.2 }
739 jsr166 1.22 finally {
740 jsr166 1.33 joinPool(p);
741 dl 1.2 }
742 dl 1.1 }
743    
744 dl 1.10 /**
745     * completed submit of callable returns result
746     */
747 jsr166 1.25 public void testSubmitCallable() throws Exception {
748 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
749     try {
750     Future<String> future = e.submit(new StringTask());
751     String result = future.get();
752     assertSame(TEST_STRING, result);
753     } finally {
754     joinPool(e);
755     }
756     }
757    
758     /**
759     * completed submit of runnable returns successfully
760     */
761 jsr166 1.25 public void testSubmitRunnable() throws Exception {
762 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
763     try {
764     Future<?> future = e.submit(new NoOpRunnable());
765     future.get();
766     assertTrue(future.isDone());
767     } finally {
768     joinPool(e);
769     }
770     }
771    
772     /**
773     * completed submit of (runnable, result) returns result
774     */
775 jsr166 1.25 public void testSubmitRunnable2() throws Exception {
776 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
777     try {
778     Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
779     String result = future.get();
780     assertSame(TEST_STRING, result);
781     } finally {
782     joinPool(e);
783     }
784     }
785    
786     /**
787     * invokeAny(null) throws NPE
788     */
789 jsr166 1.25 public void testInvokeAny1() throws Exception {
790 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
791     try {
792     e.invokeAny(null);
793 jsr166 1.25 shouldThrow();
794 dl 1.10 } catch (NullPointerException success) {
795     } finally {
796     joinPool(e);
797     }
798     }
799    
800     /**
801     * invokeAny(empty collection) throws IAE
802     */
803 jsr166 1.25 public void testInvokeAny2() throws Exception {
804 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
805     try {
806     e.invokeAny(new ArrayList<Callable<String>>());
807 jsr166 1.25 shouldThrow();
808 dl 1.10 } catch (IllegalArgumentException success) {
809     } finally {
810     joinPool(e);
811     }
812     }
813    
814     /**
815     * invokeAny(c) throws NPE if c has null elements
816     */
817 jsr166 1.25 public void testInvokeAny3() throws Exception {
818 jsr166 1.29 CountDownLatch latch = new CountDownLatch(1);
819 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
820 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
821     l.add(latchAwaitingStringTask(latch));
822     l.add(null);
823 dl 1.10 try {
824     e.invokeAny(l);
825 jsr166 1.25 shouldThrow();
826 dl 1.10 } catch (NullPointerException success) {
827     } finally {
828 jsr166 1.25 latch.countDown();
829 dl 1.10 joinPool(e);
830     }
831     }
832    
833     /**
834     * invokeAny(c) throws ExecutionException if no task completes
835     */
836 jsr166 1.25 public void testInvokeAny4() throws Exception {
837 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
838 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
839     l.add(new NPETask());
840 dl 1.10 try {
841     e.invokeAny(l);
842 jsr166 1.25 shouldThrow();
843 dl 1.10 } catch (ExecutionException success) {
844 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
845 dl 1.10 } finally {
846     joinPool(e);
847     }
848     }
849    
850     /**
851     * invokeAny(c) returns result of some task
852     */
853 jsr166 1.25 public void testInvokeAny5() throws Exception {
854 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
855     try {
856 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
857 dl 1.10 l.add(new StringTask());
858     l.add(new StringTask());
859     String result = e.invokeAny(l);
860     assertSame(TEST_STRING, result);
861     } finally {
862     joinPool(e);
863     }
864     }
865    
866     /**
867     * invokeAll(null) throws NPE
868     */
869 jsr166 1.25 public void testInvokeAll1() throws Exception {
870 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
871     try {
872     e.invokeAll(null);
873 jsr166 1.25 shouldThrow();
874 dl 1.10 } catch (NullPointerException success) {
875     } finally {
876     joinPool(e);
877     }
878     }
879    
880     /**
881     * invokeAll(empty collection) returns empty collection
882     */
883 jsr166 1.25 public void testInvokeAll2() throws Exception {
884 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
885     try {
886     List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
887     assertTrue(r.isEmpty());
888     } finally {
889     joinPool(e);
890     }
891     }
892    
893     /**
894     * invokeAll(c) throws NPE if c has null elements
895     */
896 jsr166 1.25 public void testInvokeAll3() throws Exception {
897 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
898 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
899     l.add(new StringTask());
900     l.add(null);
901 dl 1.10 try {
902     e.invokeAll(l);
903 jsr166 1.25 shouldThrow();
904 dl 1.10 } catch (NullPointerException success) {
905     } finally {
906     joinPool(e);
907     }
908     }
909    
910     /**
911     * get of invokeAll(c) throws exception on failed task
912     */
913 jsr166 1.25 public void testInvokeAll4() throws Exception {
914 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
915 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
916     l.add(new NPETask());
917     List<Future<String>> futures = e.invokeAll(l);
918     assertEquals(1, futures.size());
919 dl 1.10 try {
920 jsr166 1.29 futures.get(0).get();
921 jsr166 1.25 shouldThrow();
922 jsr166 1.23 } catch (ExecutionException success) {
923 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
924 dl 1.10 } finally {
925     joinPool(e);
926     }
927     }
928    
929     /**
930     * invokeAll(c) returns results of all completed tasks
931     */
932 jsr166 1.25 public void testInvokeAll5() throws Exception {
933 dl 1.10 ExecutorService e = new ScheduledThreadPoolExecutor(2);
934     try {
935 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
936 dl 1.10 l.add(new StringTask());
937     l.add(new StringTask());
938 jsr166 1.29 List<Future<String>> futures = e.invokeAll(l);
939     assertEquals(2, futures.size());
940     for (Future<String> future : futures)
941 jsr166 1.25 assertSame(TEST_STRING, future.get());
942 dl 1.10 } finally {
943     joinPool(e);
944     }
945     }
946    
947 dl 1.11 /**
948     * timed invokeAny(null) throws NPE
949     */
950 jsr166 1.25 public void testTimedInvokeAny1() throws Exception {
951 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
952     try {
953 jsr166 1.25 e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
954     shouldThrow();
955 dl 1.11 } catch (NullPointerException success) {
956     } finally {
957     joinPool(e);
958     }
959     }
960    
961     /**
962     * timed invokeAny(,,null) throws NPE
963     */
964 jsr166 1.25 public void testTimedInvokeAnyNullTimeUnit() throws Exception {
965 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
966 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
967     l.add(new StringTask());
968 dl 1.11 try {
969     e.invokeAny(l, MEDIUM_DELAY_MS, null);
970 jsr166 1.25 shouldThrow();
971 dl 1.11 } catch (NullPointerException success) {
972     } finally {
973     joinPool(e);
974     }
975     }
976    
977     /**
978     * timed invokeAny(empty collection) throws IAE
979     */
980 jsr166 1.25 public void testTimedInvokeAny2() throws Exception {
981 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
982     try {
983 jsr166 1.25 e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
984     shouldThrow();
985 dl 1.11 } catch (IllegalArgumentException success) {
986     } finally {
987     joinPool(e);
988     }
989     }
990    
991     /**
992     * timed invokeAny(c) throws NPE if c has null elements
993     */
994 jsr166 1.25 public void testTimedInvokeAny3() throws Exception {
995 jsr166 1.29 CountDownLatch latch = new CountDownLatch(1);
996 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
997 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
998     l.add(latchAwaitingStringTask(latch));
999     l.add(null);
1000 dl 1.11 try {
1001 jsr166 1.25 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1002     shouldThrow();
1003 dl 1.11 } catch (NullPointerException success) {
1004     } finally {
1005 jsr166 1.25 latch.countDown();
1006 dl 1.11 joinPool(e);
1007     }
1008     }
1009    
1010     /**
1011     * timed invokeAny(c) throws ExecutionException if no task completes
1012     */
1013 jsr166 1.25 public void testTimedInvokeAny4() throws Exception {
1014 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1015 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1016     l.add(new NPETask());
1017 dl 1.11 try {
1018 jsr166 1.25 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1019     shouldThrow();
1020 jsr166 1.23 } catch (ExecutionException success) {
1021 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
1022 dl 1.11 } finally {
1023     joinPool(e);
1024     }
1025     }
1026    
1027     /**
1028     * timed invokeAny(c) returns result of some task
1029     */
1030 jsr166 1.25 public void testTimedInvokeAny5() throws Exception {
1031 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1032     try {
1033 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1034 dl 1.11 l.add(new StringTask());
1035     l.add(new StringTask());
1036 jsr166 1.25 String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1037 dl 1.11 assertSame(TEST_STRING, result);
1038     } finally {
1039     joinPool(e);
1040     }
1041     }
1042    
1043     /**
1044     * timed invokeAll(null) throws NPE
1045     */
1046 jsr166 1.25 public void testTimedInvokeAll1() throws Exception {
1047 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1048     try {
1049 jsr166 1.25 e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1050     shouldThrow();
1051 dl 1.11 } catch (NullPointerException success) {
1052     } finally {
1053     joinPool(e);
1054     }
1055     }
1056    
1057     /**
1058     * timed invokeAll(,,null) throws NPE
1059     */
1060 jsr166 1.25 public void testTimedInvokeAllNullTimeUnit() throws Exception {
1061 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1062 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1063     l.add(new StringTask());
1064 dl 1.11 try {
1065     e.invokeAll(l, MEDIUM_DELAY_MS, null);
1066 jsr166 1.25 shouldThrow();
1067 dl 1.11 } catch (NullPointerException success) {
1068     } finally {
1069     joinPool(e);
1070     }
1071     }
1072    
1073     /**
1074     * timed invokeAll(empty collection) returns empty collection
1075     */
1076 jsr166 1.25 public void testTimedInvokeAll2() throws Exception {
1077 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1078     try {
1079 jsr166 1.25 List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1080 dl 1.11 assertTrue(r.isEmpty());
1081     } finally {
1082     joinPool(e);
1083     }
1084     }
1085    
1086     /**
1087     * timed invokeAll(c) throws NPE if c has null elements
1088     */
1089 jsr166 1.25 public void testTimedInvokeAll3() throws Exception {
1090 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1091 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1092     l.add(new StringTask());
1093     l.add(null);
1094 dl 1.11 try {
1095 jsr166 1.25 e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1096     shouldThrow();
1097 dl 1.11 } catch (NullPointerException success) {
1098     } finally {
1099     joinPool(e);
1100     }
1101     }
1102    
1103     /**
1104     * get of element of invokeAll(c) throws exception on failed task
1105     */
1106 jsr166 1.25 public void testTimedInvokeAll4() throws Exception {
1107 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1108 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1109     l.add(new NPETask());
1110     List<Future<String>> futures =
1111     e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1112     assertEquals(1, futures.size());
1113 dl 1.11 try {
1114 jsr166 1.29 futures.get(0).get();
1115 jsr166 1.25 shouldThrow();
1116 jsr166 1.23 } catch (ExecutionException success) {
1117 jsr166 1.25 assertTrue(success.getCause() instanceof NullPointerException);
1118 dl 1.11 } finally {
1119     joinPool(e);
1120     }
1121     }
1122    
1123     /**
1124     * timed invokeAll(c) returns results of all completed tasks
1125     */
1126 jsr166 1.25 public void testTimedInvokeAll5() throws Exception {
1127 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1128     try {
1129 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1130 dl 1.11 l.add(new StringTask());
1131     l.add(new StringTask());
1132 jsr166 1.29 List<Future<String>> futures =
1133     e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1134     assertEquals(2, futures.size());
1135     for (Future<String> future : futures)
1136 jsr166 1.25 assertSame(TEST_STRING, future.get());
1137 dl 1.11 } finally {
1138     joinPool(e);
1139     }
1140     }
1141    
1142     /**
1143     * timed invokeAll(c) cancels tasks not completed by timeout
1144     */
1145 jsr166 1.25 public void testTimedInvokeAll6() throws Exception {
1146 dl 1.11 ExecutorService e = new ScheduledThreadPoolExecutor(2);
1147     try {
1148 jsr166 1.29 List<Callable<String>> l = new ArrayList<Callable<String>>();
1149 dl 1.11 l.add(new StringTask());
1150 dl 1.12 l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1151 dl 1.14 l.add(new StringTask());
1152 jsr166 1.29 List<Future<String>> futures =
1153     e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1154     assertEquals(3, futures.size());
1155     Iterator<Future<String>> it = futures.iterator();
1156 dl 1.11 Future<String> f1 = it.next();
1157     Future<String> f2 = it.next();
1158 dl 1.14 Future<String> f3 = it.next();
1159 dl 1.11 assertTrue(f1.isDone());
1160 dl 1.14 assertTrue(f2.isDone());
1161     assertTrue(f3.isDone());
1162 dl 1.11 assertFalse(f1.isCancelled());
1163     assertTrue(f2.isCancelled());
1164     } finally {
1165     joinPool(e);
1166     }
1167     }
1168    
1169 dl 1.10
1170 dl 1.1 }