ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ScheduledExecutorTest.java
Revision: 1.19
Committed: Thu Jan 22 14:07:50 2004 UTC (20 years, 3 months ago) by dl
Branch: MAIN
Changes since 1.18: +22 -9 lines
Log Message: 
Fixed 2 tests

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