ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorTest.java
Revision: 1.32
Committed: Tue Dec 1 09:48:12 2009 UTC (14 years, 5 months ago) by jsr166
Branch: MAIN
Changes since 1.31: +0 -1 lines
Log Message: 
whitespace

File Contents

# User Rev Content
1 dl 1.1 /*
2 dl 1.15 * 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.24 * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7 dl 1.1 */
8    
9     import java.util.concurrent.*;
10 jsr166 1.27 import static java.util.concurrent.TimeUnit.MILLISECONDS;
11 dl 1.23 import java.util.concurrent.atomic.*;
12 dl 1.1 import junit.framework.*;
13 dl 1.12 import java.util.*;
14 dl 1.1
15 dl 1.3 public class ThreadPoolExecutorTest extends JSR166TestCase {
16 dl 1.1 public static void main(String[] args) {
17 jsr166 1.31 junit.textui.TestRunner.run (suite());
18 dl 1.1 }
19     public static Test suite() {
20     return new TestSuite(ThreadPoolExecutorTest.class);
21     }
22 jsr166 1.24
23 dl 1.8 static class ExtendedTPE extends ThreadPoolExecutor {
24     volatile boolean beforeCalled = false;
25     volatile boolean afterCalled = false;
26     volatile boolean terminatedCalled = false;
27     public ExtendedTPE() {
28 jsr166 1.27 super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
29 dl 1.8 }
30     protected void beforeExecute(Thread t, Runnable r) {
31     beforeCalled = true;
32     }
33     protected void afterExecute(Runnable r, Throwable t) {
34     afterCalled = true;
35     }
36     protected void terminated() {
37     terminatedCalled = true;
38     }
39     }
40 dl 1.1
41 jsr166 1.26 static class FailingThreadFactory implements ThreadFactory {
42 dl 1.19 int calls = 0;
43 jsr166 1.26 public Thread newThread(Runnable r) {
44 dl 1.20 if (++calls > 1) return null;
45 dl 1.19 return new Thread(r);
46 jsr166 1.24 }
47 dl 1.19 }
48 jsr166 1.24
49 dl 1.19
50 dl 1.3 /**
51 dl 1.8 * execute successfully executes a runnable
52 dl 1.1 */
53 jsr166 1.27 public void testExecute() throws InterruptedException {
54     ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
55 dl 1.1 try {
56 jsr166 1.27 p1.execute(new ShortRunnable());
57 jsr166 1.31 Thread.sleep(SMALL_DELAY_MS);
58 jsr166 1.27 } finally {
59     joinPool(p1);
60 jsr166 1.24 }
61 dl 1.1 }
62    
63     /**
64 dl 1.6 * getActiveCount increases but doesn't overestimate, when a
65     * thread becomes active
66 dl 1.1 */
67 jsr166 1.27 public void testGetActiveCount() throws InterruptedException {
68     ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
69 dl 1.5 assertEquals(0, p2.getActiveCount());
70     p2.execute(new MediumRunnable());
71 jsr166 1.27 Thread.sleep(SHORT_DELAY_MS);
72 dl 1.5 assertEquals(1, p2.getActiveCount());
73     joinPool(p2);
74 dl 1.1 }
75 dl 1.8
76     /**
77     * prestartCoreThread starts a thread if under corePoolSize, else doesn't
78     */
79     public void testPrestartCoreThread() {
80 jsr166 1.27 ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
81 dl 1.8 assertEquals(0, p2.getPoolSize());
82     assertTrue(p2.prestartCoreThread());
83     assertEquals(1, p2.getPoolSize());
84     assertTrue(p2.prestartCoreThread());
85     assertEquals(2, p2.getPoolSize());
86     assertFalse(p2.prestartCoreThread());
87     assertEquals(2, p2.getPoolSize());
88     joinPool(p2);
89     }
90    
91     /**
92     * prestartAllCoreThreads starts all corePoolSize threads
93     */
94     public void testPrestartAllCoreThreads() {
95 jsr166 1.27 ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
96 dl 1.8 assertEquals(0, p2.getPoolSize());
97     p2.prestartAllCoreThreads();
98     assertEquals(2, p2.getPoolSize());
99     p2.prestartAllCoreThreads();
100     assertEquals(2, p2.getPoolSize());
101     joinPool(p2);
102     }
103 jsr166 1.24
104 dl 1.1 /**
105 dl 1.6 * getCompletedTaskCount increases, but doesn't overestimate,
106     * when tasks complete
107 dl 1.1 */
108 jsr166 1.27 public void testGetCompletedTaskCount() throws InterruptedException {
109     ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
110 dl 1.5 assertEquals(0, p2.getCompletedTaskCount());
111     p2.execute(new ShortRunnable());
112 jsr166 1.27 Thread.sleep(SMALL_DELAY_MS);
113 dl 1.5 assertEquals(1, p2.getCompletedTaskCount());
114 jsr166 1.25 try { p2.shutdown(); } catch (SecurityException ok) { return; }
115 dl 1.5 joinPool(p2);
116 dl 1.1 }
117 jsr166 1.24
118 dl 1.1 /**
119 dl 1.6 * getCorePoolSize returns size given in constructor if not otherwise set
120 dl 1.1 */
121 dl 1.5 public void testGetCorePoolSize() {
122 jsr166 1.27 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
123 dl 1.5 assertEquals(1, p1.getCorePoolSize());
124     joinPool(p1);
125 dl 1.1 }
126 jsr166 1.24
127 dl 1.1 /**
128 dl 1.6 * getKeepAliveTime returns value given in constructor if not otherwise set
129 dl 1.1 */
130 dl 1.5 public void testGetKeepAliveTime() {
131 jsr166 1.27 ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
132 dl 1.5 assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS));
133     joinPool(p2);
134 dl 1.1 }
135 dl 1.8
136    
137 jsr166 1.24 /**
138 dl 1.8 * getThreadFactory returns factory in constructor if not set
139     */
140     public void testGetThreadFactory() {
141     ThreadFactory tf = new SimpleThreadFactory();
142 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
143 dl 1.8 assertSame(tf, p.getThreadFactory());
144     joinPool(p);
145     }
146    
147 jsr166 1.24 /**
148 dl 1.8 * setThreadFactory sets the thread factory returned by getThreadFactory
149     */
150     public void testSetThreadFactory() {
151 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
152 dl 1.8 ThreadFactory tf = new SimpleThreadFactory();
153     p.setThreadFactory(tf);
154     assertSame(tf, p.getThreadFactory());
155     joinPool(p);
156     }
157    
158    
159 jsr166 1.24 /**
160 dl 1.8 * setThreadFactory(null) throws NPE
161     */
162     public void testSetThreadFactoryNull() {
163 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
164 dl 1.8 try {
165     p.setThreadFactory(null);
166     shouldThrow();
167     } catch (NullPointerException success) {
168     } finally {
169     joinPool(p);
170     }
171     }
172    
173 jsr166 1.24 /**
174 dl 1.9 * getRejectedExecutionHandler returns handler in constructor if not set
175     */
176     public void testGetRejectedExecutionHandler() {
177     RejectedExecutionHandler h = new NoOpREHandler();
178 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
179 dl 1.9 assertSame(h, p.getRejectedExecutionHandler());
180     joinPool(p);
181     }
182    
183 jsr166 1.24 /**
184 dl 1.9 * setRejectedExecutionHandler sets the handler returned by
185     * getRejectedExecutionHandler
186     */
187     public void testSetRejectedExecutionHandler() {
188 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
189 dl 1.9 RejectedExecutionHandler h = new NoOpREHandler();
190     p.setRejectedExecutionHandler(h);
191     assertSame(h, p.getRejectedExecutionHandler());
192     joinPool(p);
193     }
194    
195    
196 jsr166 1.24 /**
197 dl 1.9 * setRejectedExecutionHandler(null) throws NPE
198     */
199     public void testSetRejectedExecutionHandlerNull() {
200 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
201 dl 1.9 try {
202     p.setRejectedExecutionHandler(null);
203     shouldThrow();
204     } catch (NullPointerException success) {
205     } finally {
206     joinPool(p);
207     }
208     }
209    
210 jsr166 1.24
211 dl 1.1 /**
212 dl 1.6 * getLargestPoolSize increases, but doesn't overestimate, when
213     * multiple threads active
214 dl 1.1 */
215 jsr166 1.27 public void testGetLargestPoolSize() throws InterruptedException {
216     ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
217     assertEquals(0, p2.getLargestPoolSize());
218     p2.execute(new MediumRunnable());
219     p2.execute(new MediumRunnable());
220     Thread.sleep(SHORT_DELAY_MS);
221     assertEquals(2, p2.getLargestPoolSize());
222 dl 1.5 joinPool(p2);
223 dl 1.1 }
224 jsr166 1.24
225 dl 1.1 /**
226 dl 1.6 * getMaximumPoolSize returns value given in constructor if not
227     * otherwise set
228 dl 1.1 */
229 dl 1.5 public void testGetMaximumPoolSize() {
230 jsr166 1.27 ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
231 dl 1.5 assertEquals(2, p2.getMaximumPoolSize());
232     joinPool(p2);
233 dl 1.1 }
234 jsr166 1.24
235 dl 1.1 /**
236 dl 1.6 * getPoolSize increases, but doesn't overestimate, when threads
237     * become active
238 dl 1.1 */
239 dl 1.5 public void testGetPoolSize() {
240 jsr166 1.27 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
241 dl 1.5 assertEquals(0, p1.getPoolSize());
242     p1.execute(new MediumRunnable());
243     assertEquals(1, p1.getPoolSize());
244     joinPool(p1);
245 dl 1.1 }
246 jsr166 1.24
247 dl 1.1 /**
248 dl 1.8 * getTaskCount increases, but doesn't overestimate, when tasks submitted
249 dl 1.1 */
250 jsr166 1.27 public void testGetTaskCount() throws InterruptedException {
251     ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
252     assertEquals(0, p1.getTaskCount());
253     p1.execute(new MediumRunnable());
254     Thread.sleep(SHORT_DELAY_MS);
255     assertEquals(1, p1.getTaskCount());
256 dl 1.5 joinPool(p1);
257 dl 1.1 }
258 jsr166 1.24
259 dl 1.1 /**
260 dl 1.6 * isShutDown is false before shutdown, true after
261 dl 1.1 */
262 dl 1.5 public void testIsShutdown() {
263 jsr166 1.24
264 jsr166 1.31 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
265 dl 1.5 assertFalse(p1.isShutdown());
266 jsr166 1.25 try { p1.shutdown(); } catch (SecurityException ok) { return; }
267 jsr166 1.31 assertTrue(p1.isShutdown());
268 dl 1.5 joinPool(p1);
269 dl 1.1 }
270    
271 jsr166 1.24
272 dl 1.1 /**
273 dl 1.6 * isTerminated is false before termination, true after
274 dl 1.1 */
275 jsr166 1.27 public void testIsTerminated() throws InterruptedException {
276 jsr166 1.31 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
277 dl 1.6 assertFalse(p1.isTerminated());
278 dl 1.1 try {
279 dl 1.5 p1.execute(new MediumRunnable());
280 dl 1.1 } finally {
281 jsr166 1.25 try { p1.shutdown(); } catch (SecurityException ok) { return; }
282 dl 1.1 }
283 jsr166 1.27 assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
284     assertTrue(p1.isTerminated());
285 dl 1.5 }
286    
287     /**
288 dl 1.6 * isTerminating is not true when running or when terminated
289 dl 1.5 */
290 jsr166 1.27 public void testIsTerminating() throws InterruptedException {
291 jsr166 1.31 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
292 dl 1.5 assertFalse(p1.isTerminating());
293     try {
294     p1.execute(new SmallRunnable());
295     assertFalse(p1.isTerminating());
296     } finally {
297 jsr166 1.25 try { p1.shutdown(); } catch (SecurityException ok) { return; }
298 dl 1.5 }
299 jsr166 1.27 assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
300     assertTrue(p1.isTerminated());
301     assertFalse(p1.isTerminating());
302 dl 1.1 }
303    
304     /**
305 dl 1.8 * getQueue returns the work queue, which contains queued tasks
306     */
307 jsr166 1.27 public void testGetQueue() throws InterruptedException {
308 dl 1.8 BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
309 jsr166 1.27 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, q);
310 dl 1.11 FutureTask[] tasks = new FutureTask[5];
311 jsr166 1.26 for (int i = 0; i < 5; i++) {
312 dl 1.11 tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
313 dl 1.8 p1.execute(tasks[i]);
314     }
315     try {
316     Thread.sleep(SHORT_DELAY_MS);
317     BlockingQueue<Runnable> wq = p1.getQueue();
318     assertSame(q, wq);
319     assertFalse(wq.contains(tasks[0]));
320     assertTrue(wq.contains(tasks[4]));
321 dl 1.22 for (int i = 1; i < 5; ++i)
322     tasks[i].cancel(true);
323     p1.shutdownNow();
324 dl 1.8 } finally {
325     joinPool(p1);
326     }
327     }
328    
329     /**
330     * remove(task) removes queued task, and fails to remove active task
331     */
332 jsr166 1.27 public void testRemove() throws InterruptedException {
333 dl 1.8 BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
334 jsr166 1.27 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, q);
335 dl 1.11 FutureTask[] tasks = new FutureTask[5];
336 jsr166 1.26 for (int i = 0; i < 5; i++) {
337 dl 1.11 tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
338 dl 1.8 p1.execute(tasks[i]);
339     }
340     try {
341     Thread.sleep(SHORT_DELAY_MS);
342     assertFalse(p1.remove(tasks[0]));
343     assertTrue(q.contains(tasks[4]));
344     assertTrue(q.contains(tasks[3]));
345     assertTrue(p1.remove(tasks[4]));
346     assertFalse(p1.remove(tasks[4]));
347     assertFalse(q.contains(tasks[4]));
348     assertTrue(q.contains(tasks[3]));
349     assertTrue(p1.remove(tasks[3]));
350     assertFalse(q.contains(tasks[3]));
351     } finally {
352     joinPool(p1);
353     }
354     }
355    
356     /**
357 dl 1.6 * purge removes cancelled tasks from the queue
358 dl 1.1 */
359 dl 1.5 public void testPurge() {
360 jsr166 1.27 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
361 dl 1.11 FutureTask[] tasks = new FutureTask[5];
362 jsr166 1.26 for (int i = 0; i < 5; i++) {
363 dl 1.11 tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
364 dl 1.5 p1.execute(tasks[i]);
365 dl 1.3 }
366     tasks[4].cancel(true);
367     tasks[3].cancel(true);
368 dl 1.5 p1.purge();
369     long count = p1.getTaskCount();
370 dl 1.3 assertTrue(count >= 2 && count < 5);
371 dl 1.5 joinPool(p1);
372 dl 1.1 }
373    
374     /**
375 dl 1.6 * shutDownNow returns a list containing tasks that were not run
376 dl 1.1 */
377 dl 1.5 public void testShutDownNow() {
378 jsr166 1.31 ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
379 dl 1.1 List l;
380     try {
381 jsr166 1.25 for (int i = 0; i < 5; i++)
382 dl 1.5 p1.execute(new MediumPossiblyInterruptedRunnable());
383 dl 1.1 }
384     finally {
385 dl 1.17 try {
386     l = p1.shutdownNow();
387     } catch (SecurityException ok) { return; }
388 dl 1.1 }
389 jsr166 1.31 assertTrue(p1.isShutdown());
390     assertTrue(l.size() <= 4);
391 dl 1.1 }
392    
393     // Exception Tests
394    
395 jsr166 1.24
396     /**
397     * Constructor throws if corePoolSize argument is less than zero
398 dl 1.6 */
399 dl 1.1 public void testConstructor1() {
400 dl 1.5 try {
401 jsr166 1.27 new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
402 dl 1.5 shouldThrow();
403 jsr166 1.28 } catch (IllegalArgumentException success) {}
404 dl 1.1 }
405 jsr166 1.24
406     /**
407     * Constructor throws if maximumPoolSize is less than zero
408 dl 1.6 */
409 dl 1.1 public void testConstructor2() {
410 dl 1.5 try {
411 jsr166 1.27 new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
412 dl 1.5 shouldThrow();
413 jsr166 1.28 } catch (IllegalArgumentException success) {}
414 dl 1.1 }
415 jsr166 1.24
416     /**
417     * Constructor throws if maximumPoolSize is equal to zero
418 dl 1.6 */
419 dl 1.1 public void testConstructor3() {
420 dl 1.5 try {
421 jsr166 1.27 new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
422 dl 1.5 shouldThrow();
423 jsr166 1.28 } catch (IllegalArgumentException success) {}
424 dl 1.1 }
425    
426 jsr166 1.24 /**
427     * Constructor throws if keepAliveTime is less than zero
428 dl 1.6 */
429 dl 1.1 public void testConstructor4() {
430 dl 1.5 try {
431 jsr166 1.27 new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
432 dl 1.5 shouldThrow();
433 jsr166 1.28 } catch (IllegalArgumentException success) {}
434 dl 1.1 }
435    
436 jsr166 1.24 /**
437     * Constructor throws if corePoolSize is greater than the maximumPoolSize
438 dl 1.6 */
439 dl 1.1 public void testConstructor5() {
440 dl 1.5 try {
441 jsr166 1.27 new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
442 dl 1.5 shouldThrow();
443 jsr166 1.28 } catch (IllegalArgumentException success) {}
444 dl 1.1 }
445 jsr166 1.24
446     /**
447     * Constructor throws if workQueue is set to null
448 dl 1.6 */
449 dl 1.8 public void testConstructorNullPointerException() {
450 dl 1.5 try {
451 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null);
452 dl 1.5 shouldThrow();
453 jsr166 1.28 } catch (NullPointerException success) {}
454 dl 1.1 }
455    
456 jsr166 1.24
457    
458     /**
459     * Constructor throws if corePoolSize argument is less than zero
460 dl 1.6 */
461 dl 1.1 public void testConstructor6() {
462 dl 1.5 try {
463 jsr166 1.27 new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
464 dl 1.5 shouldThrow();
465 jsr166 1.28 } catch (IllegalArgumentException success) {}
466 dl 1.1 }
467 jsr166 1.24
468     /**
469     * Constructor throws if maximumPoolSize is less than zero
470 dl 1.6 */
471 dl 1.1 public void testConstructor7() {
472 dl 1.5 try {
473 jsr166 1.27 new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
474 dl 1.5 shouldThrow();
475 jsr166 1.28 } catch (IllegalArgumentException success) {}
476 dl 1.1 }
477    
478 jsr166 1.24 /**
479     * Constructor throws if maximumPoolSize is equal to zero
480 dl 1.6 */
481 dl 1.1 public void testConstructor8() {
482 dl 1.5 try {
483 jsr166 1.27 new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
484 dl 1.5 shouldThrow();
485 jsr166 1.28 } catch (IllegalArgumentException success) {}
486 dl 1.1 }
487    
488 jsr166 1.24 /**
489     * Constructor throws if keepAliveTime is less than zero
490 dl 1.6 */
491 dl 1.1 public void testConstructor9() {
492 dl 1.5 try {
493 jsr166 1.27 new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
494 dl 1.5 shouldThrow();
495 jsr166 1.28 } catch (IllegalArgumentException success) {}
496 dl 1.1 }
497    
498 jsr166 1.24 /**
499     * Constructor throws if corePoolSize is greater than the maximumPoolSize
500 dl 1.6 */
501 dl 1.1 public void testConstructor10() {
502 dl 1.5 try {
503 jsr166 1.27 new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
504 dl 1.5 shouldThrow();
505 jsr166 1.28 } catch (IllegalArgumentException success) {}
506 dl 1.1 }
507    
508 jsr166 1.24 /**
509     * Constructor throws if workQueue is set to null
510 dl 1.6 */
511 dl 1.8 public void testConstructorNullPointerException2() {
512 dl 1.5 try {
513 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory());
514 dl 1.5 shouldThrow();
515 jsr166 1.28 } catch (NullPointerException success) {}
516 dl 1.1 }
517    
518 jsr166 1.24 /**
519     * Constructor throws if threadFactory is set to null
520 dl 1.6 */
521 dl 1.8 public void testConstructorNullPointerException3() {
522 dl 1.5 try {
523 dl 1.1 ThreadFactory f = null;
524 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
525 dl 1.5 shouldThrow();
526 jsr166 1.28 } catch (NullPointerException success) {}
527 dl 1.1 }
528 jsr166 1.24
529    
530     /**
531     * Constructor throws if corePoolSize argument is less than zero
532 dl 1.6 */
533 dl 1.1 public void testConstructor11() {
534 dl 1.5 try {
535 jsr166 1.27 new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
536 dl 1.5 shouldThrow();
537 jsr166 1.28 } catch (IllegalArgumentException success) {}
538 dl 1.1 }
539    
540 jsr166 1.24 /**
541     * Constructor throws if maximumPoolSize is less than zero
542 dl 1.6 */
543 dl 1.1 public void testConstructor12() {
544 dl 1.5 try {
545 jsr166 1.27 new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
546 dl 1.5 shouldThrow();
547 jsr166 1.28 } catch (IllegalArgumentException success) {}
548 dl 1.1 }
549    
550 jsr166 1.24 /**
551     * Constructor throws if maximumPoolSize is equal to zero
552 dl 1.6 */
553 dl 1.1 public void testConstructor13() {
554 dl 1.5 try {
555 jsr166 1.27 new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
556 dl 1.5 shouldThrow();
557 jsr166 1.28 } catch (IllegalArgumentException success) {}
558 dl 1.1 }
559    
560 jsr166 1.24 /**
561     * Constructor throws if keepAliveTime is less than zero
562 dl 1.6 */
563 dl 1.1 public void testConstructor14() {
564 dl 1.5 try {
565 jsr166 1.27 new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
566 dl 1.5 shouldThrow();
567 jsr166 1.28 } catch (IllegalArgumentException success) {}
568 dl 1.1 }
569    
570 jsr166 1.24 /**
571     * Constructor throws if corePoolSize is greater than the maximumPoolSize
572 dl 1.6 */
573 dl 1.1 public void testConstructor15() {
574 dl 1.5 try {
575 jsr166 1.27 new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
576 dl 1.5 shouldThrow();
577 jsr166 1.28 } catch (IllegalArgumentException success) {}
578 dl 1.1 }
579    
580 jsr166 1.24 /**
581     * Constructor throws if workQueue is set to null
582 dl 1.6 */
583 dl 1.8 public void testConstructorNullPointerException4() {
584 dl 1.5 try {
585 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null,new NoOpREHandler());
586 dl 1.5 shouldThrow();
587 jsr166 1.28 } catch (NullPointerException success) {}
588 dl 1.1 }
589    
590 jsr166 1.24 /**
591     * Constructor throws if handler is set to null
592 dl 1.6 */
593 dl 1.8 public void testConstructorNullPointerException5() {
594 dl 1.5 try {
595 dl 1.1 RejectedExecutionHandler r = null;
596 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
597 dl 1.5 shouldThrow();
598 jsr166 1.28 } catch (NullPointerException success) {}
599 dl 1.1 }
600    
601 jsr166 1.24
602     /**
603     * Constructor throws if corePoolSize argument is less than zero
604 dl 1.6 */
605 dl 1.1 public void testConstructor16() {
606 dl 1.5 try {
607 jsr166 1.27 new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
608 dl 1.5 shouldThrow();
609 jsr166 1.28 } catch (IllegalArgumentException success) {}
610 dl 1.1 }
611    
612 jsr166 1.24 /**
613     * Constructor throws if maximumPoolSize is less than zero
614 dl 1.6 */
615 dl 1.1 public void testConstructor17() {
616 dl 1.5 try {
617 jsr166 1.27 new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
618 dl 1.5 shouldThrow();
619 jsr166 1.28 } catch (IllegalArgumentException success) {}
620 dl 1.1 }
621    
622 jsr166 1.24 /**
623     * Constructor throws if maximumPoolSize is equal to zero
624 dl 1.6 */
625 dl 1.1 public void testConstructor18() {
626 dl 1.5 try {
627 jsr166 1.27 new ThreadPoolExecutor(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
628 dl 1.5 shouldThrow();
629 jsr166 1.28 } catch (IllegalArgumentException success) {}
630 dl 1.1 }
631    
632 jsr166 1.24 /**
633     * Constructor throws if keepAliveTime is less than zero
634 dl 1.6 */
635 dl 1.1 public void testConstructor19() {
636 dl 1.5 try {
637 jsr166 1.27 new ThreadPoolExecutor(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
638 dl 1.5 shouldThrow();
639 jsr166 1.28 } catch (IllegalArgumentException success) {}
640 dl 1.1 }
641    
642 jsr166 1.24 /**
643     * Constructor throws if corePoolSize is greater than the maximumPoolSize
644 dl 1.6 */
645 dl 1.1 public void testConstructor20() {
646 dl 1.5 try {
647 jsr166 1.27 new ThreadPoolExecutor(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
648 dl 1.5 shouldThrow();
649 jsr166 1.28 } catch (IllegalArgumentException success) {}
650 dl 1.1 }
651    
652 jsr166 1.24 /**
653     * Constructor throws if workQueue is set to null
654 dl 1.6 */
655 dl 1.8 public void testConstructorNullPointerException6() {
656 dl 1.5 try {
657 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
658 dl 1.5 shouldThrow();
659 jsr166 1.28 } catch (NullPointerException success) {}
660 dl 1.1 }
661    
662 jsr166 1.24 /**
663     * Constructor throws if handler is set to null
664 dl 1.6 */
665 dl 1.8 public void testConstructorNullPointerException7() {
666 dl 1.5 try {
667 dl 1.1 RejectedExecutionHandler r = null;
668 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
669 dl 1.5 shouldThrow();
670 jsr166 1.28 } catch (NullPointerException success) {}
671 dl 1.1 }
672    
673 jsr166 1.24 /**
674     * Constructor throws if ThreadFactory is set top null
675 dl 1.6 */
676 dl 1.8 public void testConstructorNullPointerException8() {
677 dl 1.5 try {
678 dl 1.1 ThreadFactory f = null;
679 jsr166 1.27 new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
680 dl 1.5 shouldThrow();
681 jsr166 1.28 } catch (NullPointerException success) {}
682 dl 1.1 }
683 jsr166 1.24
684 dl 1.1
685     /**
686 dl 1.8 * execute throws RejectedExecutionException
687     * if saturated.
688     */
689     public void testSaturatedExecute() {
690 jsr166 1.27 ThreadPoolExecutor p =
691     new ThreadPoolExecutor(1, 1,
692     LONG_DELAY_MS, MILLISECONDS,
693     new ArrayBlockingQueue<Runnable>(1));
694 dl 1.8 try {
695 jsr166 1.27 for (int i = 0; i < 2; ++i)
696 dl 1.8 p.execute(new MediumRunnable());
697 jsr166 1.27 for (int i = 0; i < 2; ++i) {
698     try {
699     p.execute(new MediumRunnable());
700     shouldThrow();
701     } catch (RejectedExecutionException success) {}
702 dl 1.8 }
703 jsr166 1.27 } finally {
704     joinPool(p);
705     }
706 dl 1.8 }
707    
708     /**
709     * executor using CallerRunsPolicy runs task if saturated.
710     */
711     public void testSaturatedExecute2() {
712     RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
713 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
714 dl 1.8 try {
715 jsr166 1.24
716 dl 1.8 TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
717 jsr166 1.26 for (int i = 0; i < 5; ++i) {
718 dl 1.8 tasks[i] = new TrackedNoOpRunnable();
719     }
720     TrackedLongRunnable mr = new TrackedLongRunnable();
721     p.execute(mr);
722 jsr166 1.26 for (int i = 0; i < 5; ++i) {
723 dl 1.8 p.execute(tasks[i]);
724     }
725 jsr166 1.25 for (int i = 1; i < 5; ++i) {
726 dl 1.8 assertTrue(tasks[i].done);
727     }
728 jsr166 1.25 try { p.shutdownNow(); } catch (SecurityException ok) { return; }
729 dl 1.8 } finally {
730     joinPool(p);
731     }
732     }
733    
734     /**
735     * executor using DiscardPolicy drops task if saturated.
736     */
737     public void testSaturatedExecute3() {
738     RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
739 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
740 dl 1.8 try {
741 jsr166 1.24
742 dl 1.8 TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
743 jsr166 1.26 for (int i = 0; i < 5; ++i) {
744 dl 1.8 tasks[i] = new TrackedNoOpRunnable();
745     }
746     p.execute(new TrackedLongRunnable());
747 jsr166 1.26 for (int i = 0; i < 5; ++i) {
748 dl 1.8 p.execute(tasks[i]);
749     }
750 jsr166 1.26 for (int i = 0; i < 5; ++i) {
751 dl 1.8 assertFalse(tasks[i].done);
752     }
753 jsr166 1.25 try { p.shutdownNow(); } catch (SecurityException ok) { return; }
754 dl 1.8 } finally {
755     joinPool(p);
756     }
757     }
758    
759     /**
760     * executor using DiscardOldestPolicy drops oldest task if saturated.
761     */
762     public void testSaturatedExecute4() {
763     RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
764 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
765 dl 1.8 try {
766     p.execute(new TrackedLongRunnable());
767     TrackedLongRunnable r2 = new TrackedLongRunnable();
768     p.execute(r2);
769     assertTrue(p.getQueue().contains(r2));
770     TrackedNoOpRunnable r3 = new TrackedNoOpRunnable();
771     p.execute(r3);
772     assertFalse(p.getQueue().contains(r2));
773     assertTrue(p.getQueue().contains(r3));
774 jsr166 1.25 try { p.shutdownNow(); } catch (SecurityException ok) { return; }
775 dl 1.8 } finally {
776     joinPool(p);
777     }
778     }
779    
780     /**
781 dl 1.6 * execute throws RejectedExecutionException if shutdown
782 dl 1.1 */
783 dl 1.8 public void testRejectedExecutionExceptionOnShutdown() {
784 jsr166 1.24 ThreadPoolExecutor tpe =
785 jsr166 1.27 new ThreadPoolExecutor(1,1,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
786 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
787 jsr166 1.31 try {
788     tpe.execute(new NoOpRunnable());
789     shouldThrow();
790     } catch (RejectedExecutionException success) {}
791 jsr166 1.24
792 jsr166 1.31 joinPool(tpe);
793 dl 1.1 }
794 dl 1.6
795     /**
796 dl 1.8 * execute using CallerRunsPolicy drops task on shutdown
797     */
798     public void testCallerRunsOnShutdown() {
799     RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
800 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
801 dl 1.8
802 jsr166 1.25 try { p.shutdown(); } catch (SecurityException ok) { return; }
803 jsr166 1.31 try {
804 dl 1.8 TrackedNoOpRunnable r = new TrackedNoOpRunnable();
805 jsr166 1.31 p.execute(r);
806 dl 1.8 assertFalse(r.done);
807     } finally {
808     joinPool(p);
809     }
810     }
811    
812     /**
813     * execute using DiscardPolicy drops task on shutdown
814     */
815     public void testDiscardOnShutdown() {
816     RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
817 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
818 dl 1.8
819 jsr166 1.25 try { p.shutdown(); } catch (SecurityException ok) { return; }
820 jsr166 1.31 try {
821 dl 1.8 TrackedNoOpRunnable r = new TrackedNoOpRunnable();
822 jsr166 1.31 p.execute(r);
823 dl 1.8 assertFalse(r.done);
824     } finally {
825     joinPool(p);
826     }
827     }
828    
829    
830     /**
831     * execute using DiscardOldestPolicy drops task on shutdown
832 dl 1.6 */
833 dl 1.8 public void testDiscardOldestOnShutdown() {
834     RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
835 jsr166 1.27 ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
836 dl 1.8
837 jsr166 1.25 try { p.shutdown(); } catch (SecurityException ok) { return; }
838 jsr166 1.31 try {
839 dl 1.8 TrackedNoOpRunnable r = new TrackedNoOpRunnable();
840 jsr166 1.31 p.execute(r);
841 dl 1.8 assertFalse(r.done);
842     } finally {
843     joinPool(p);
844     }
845 dl 1.6 }
846    
847 dl 1.8
848 dl 1.6 /**
849     * execute (null) throws NPE
850     */
851     public void testExecuteNull() {
852 jsr166 1.28 ThreadPoolExecutor tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
853 dl 1.6 try {
854 jsr166 1.31 tpe.execute(null);
855 dl 1.6 shouldThrow();
856 jsr166 1.31 } catch (NullPointerException success) {}
857 jsr166 1.24
858 jsr166 1.31 joinPool(tpe);
859 dl 1.6 }
860 jsr166 1.24
861 dl 1.1 /**
862 dl 1.8 * setCorePoolSize of negative value throws IllegalArgumentException
863 dl 1.1 */
864 dl 1.5 public void testCorePoolSizeIllegalArgumentException() {
865 jsr166 1.31 ThreadPoolExecutor tpe =
866 jsr166 1.27 new ThreadPoolExecutor(1, 2,
867     LONG_DELAY_MS, MILLISECONDS,
868     new ArrayBlockingQueue<Runnable>(10));
869 jsr166 1.31 try {
870     tpe.setCorePoolSize(-1);
871     shouldThrow();
872     } catch (IllegalArgumentException success) {
873 dl 1.1 } finally {
874 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
875 dl 1.1 }
876 dl 1.3 joinPool(tpe);
877 jsr166 1.24 }
878 dl 1.1
879     /**
880 dl 1.6 * setMaximumPoolSize(int) throws IllegalArgumentException if
881     * given a value less the core pool size
882 jsr166 1.24 */
883 dl 1.5 public void testMaximumPoolSizeIllegalArgumentException() {
884 jsr166 1.27 ThreadPoolExecutor tpe =
885     new ThreadPoolExecutor(2, 3,
886     LONG_DELAY_MS, MILLISECONDS,
887     new ArrayBlockingQueue<Runnable>(10));
888 dl 1.5 try {
889 dl 1.1 tpe.setMaximumPoolSize(1);
890 dl 1.5 shouldThrow();
891 jsr166 1.26 } catch (IllegalArgumentException success) {
892 dl 1.1 } finally {
893 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
894 dl 1.1 }
895 dl 1.3 joinPool(tpe);
896 dl 1.1 }
897 jsr166 1.24
898 dl 1.1 /**
899 dl 1.6 * setMaximumPoolSize throws IllegalArgumentException
900     * if given a negative value
901 dl 1.1 */
902 dl 1.5 public void testMaximumPoolSizeIllegalArgumentException2() {
903 jsr166 1.27 ThreadPoolExecutor tpe =
904     new ThreadPoolExecutor(2, 3,
905     LONG_DELAY_MS, MILLISECONDS,
906     new ArrayBlockingQueue<Runnable>(10));
907 dl 1.5 try {
908 dl 1.1 tpe.setMaximumPoolSize(-1);
909 dl 1.5 shouldThrow();
910 jsr166 1.26 } catch (IllegalArgumentException success) {
911 dl 1.1 } finally {
912 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
913 dl 1.1 }
914 dl 1.3 joinPool(tpe);
915 dl 1.1 }
916 jsr166 1.24
917 dl 1.1
918     /**
919 dl 1.6 * setKeepAliveTime throws IllegalArgumentException
920 dl 1.1 * when given a negative value
921     */
922 dl 1.5 public void testKeepAliveTimeIllegalArgumentException() {
923 jsr166 1.31 ThreadPoolExecutor tpe =
924 jsr166 1.27 new ThreadPoolExecutor(2, 3,
925     LONG_DELAY_MS, MILLISECONDS,
926     new ArrayBlockingQueue<Runnable>(10));
927 jsr166 1.31 try {
928 jsr166 1.27 tpe.setKeepAliveTime(-1,MILLISECONDS);
929 dl 1.5 shouldThrow();
930 jsr166 1.26 } catch (IllegalArgumentException success) {
931 dl 1.1 } finally {
932 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
933 dl 1.1 }
934 dl 1.3 joinPool(tpe);
935 dl 1.1 }
936 dl 1.8
937     /**
938     * terminated() is called on termination
939     */
940     public void testTerminated() {
941     ExtendedTPE tpe = new ExtendedTPE();
942 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
943 dl 1.8 assertTrue(tpe.terminatedCalled);
944     joinPool(tpe);
945     }
946    
947     /**
948     * beforeExecute and afterExecute are called when executing task
949     */
950 jsr166 1.27 public void testBeforeAfter() throws InterruptedException {
951 dl 1.8 ExtendedTPE tpe = new ExtendedTPE();
952     try {
953     TrackedNoOpRunnable r = new TrackedNoOpRunnable();
954     tpe.execute(r);
955     Thread.sleep(SHORT_DELAY_MS);
956     assertTrue(r.done);
957     assertTrue(tpe.beforeCalled);
958     assertTrue(tpe.afterCalled);
959 jsr166 1.25 try { tpe.shutdown(); } catch (SecurityException ok) { return; }
960 dl 1.8 } finally {
961     joinPool(tpe);
962     }
963     }
964 dl 1.12
965     /**
966     * completed submit of callable returns result
967     */
968 jsr166 1.27 public void testSubmitCallable() throws Exception {
969     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
970 dl 1.12 try {
971     Future<String> future = e.submit(new StringTask());
972     String result = future.get();
973     assertSame(TEST_STRING, result);
974     } finally {
975     joinPool(e);
976     }
977     }
978    
979     /**
980     * completed submit of runnable returns successfully
981     */
982 jsr166 1.27 public void testSubmitRunnable() throws Exception {
983     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
984 dl 1.12 try {
985     Future<?> future = e.submit(new NoOpRunnable());
986     future.get();
987     assertTrue(future.isDone());
988     } finally {
989     joinPool(e);
990     }
991     }
992    
993     /**
994     * completed submit of (runnable, result) returns result
995     */
996 jsr166 1.27 public void testSubmitRunnable2() throws Exception {
997     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
998 dl 1.12 try {
999     Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1000     String result = future.get();
1001     assertSame(TEST_STRING, result);
1002     } finally {
1003     joinPool(e);
1004     }
1005     }
1006    
1007    
1008     /**
1009     * invokeAny(null) throws NPE
1010     */
1011 jsr166 1.27 public void testInvokeAny1() throws Exception {
1012     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1013 dl 1.12 try {
1014     e.invokeAny(null);
1015 jsr166 1.27 shouldThrow();
1016 dl 1.12 } catch (NullPointerException success) {
1017     } finally {
1018     joinPool(e);
1019     }
1020     }
1021    
1022     /**
1023     * invokeAny(empty collection) throws IAE
1024     */
1025 jsr166 1.27 public void testInvokeAny2() throws Exception {
1026     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1027 dl 1.12 try {
1028     e.invokeAny(new ArrayList<Callable<String>>());
1029 jsr166 1.27 shouldThrow();
1030 dl 1.12 } catch (IllegalArgumentException success) {
1031     } finally {
1032     joinPool(e);
1033     }
1034     }
1035    
1036     /**
1037     * invokeAny(c) throws NPE if c has null elements
1038     */
1039 jsr166 1.27 public void testInvokeAny3() throws Exception {
1040     final CountDownLatch latch = new CountDownLatch(1);
1041     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1042 dl 1.12 try {
1043     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1044 jsr166 1.29 l.add(new Callable<String>() {
1045     public String call() {
1046     try {
1047     latch.await();
1048     } catch (InterruptedException ok) {}
1049 jsr166 1.27 return TEST_STRING;
1050     }});
1051 dl 1.12 l.add(null);
1052     e.invokeAny(l);
1053 jsr166 1.27 shouldThrow();
1054 dl 1.12 } catch (NullPointerException success) {
1055     } finally {
1056 jsr166 1.27 latch.countDown();
1057 dl 1.12 joinPool(e);
1058     }
1059     }
1060    
1061     /**
1062     * invokeAny(c) throws ExecutionException if no task completes
1063     */
1064 jsr166 1.27 public void testInvokeAny4() throws Exception {
1065     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1066 dl 1.12 try {
1067     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1068     l.add(new NPETask());
1069     e.invokeAny(l);
1070 jsr166 1.27 shouldThrow();
1071 dl 1.12 } catch (ExecutionException success) {
1072 jsr166 1.27 assertTrue(success.getCause() instanceof NullPointerException);
1073 dl 1.12 } finally {
1074     joinPool(e);
1075     }
1076     }
1077    
1078     /**
1079     * invokeAny(c) returns result of some task
1080     */
1081 jsr166 1.27 public void testInvokeAny5() throws Exception {
1082     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1083 dl 1.12 try {
1084     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1085     l.add(new StringTask());
1086     l.add(new StringTask());
1087     String result = e.invokeAny(l);
1088     assertSame(TEST_STRING, result);
1089     } finally {
1090     joinPool(e);
1091     }
1092     }
1093    
1094     /**
1095     * invokeAll(null) throws NPE
1096     */
1097 jsr166 1.27 public void testInvokeAll1() throws Exception {
1098     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1099 dl 1.12 try {
1100     e.invokeAll(null);
1101 jsr166 1.27 shouldThrow();
1102 dl 1.12 } catch (NullPointerException success) {
1103     } finally {
1104     joinPool(e);
1105     }
1106     }
1107    
1108     /**
1109     * invokeAll(empty collection) returns empty collection
1110     */
1111 jsr166 1.27 public void testInvokeAll2() throws InterruptedException {
1112     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1113 dl 1.12 try {
1114     List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1115     assertTrue(r.isEmpty());
1116     } finally {
1117     joinPool(e);
1118     }
1119     }
1120    
1121     /**
1122     * invokeAll(c) throws NPE if c has null elements
1123     */
1124 jsr166 1.27 public void testInvokeAll3() throws Exception {
1125     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1126 dl 1.12 try {
1127     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1128     l.add(new StringTask());
1129     l.add(null);
1130     e.invokeAll(l);
1131 jsr166 1.27 shouldThrow();
1132 dl 1.12 } catch (NullPointerException success) {
1133     } finally {
1134     joinPool(e);
1135     }
1136     }
1137    
1138     /**
1139     * get of element of invokeAll(c) throws exception on failed task
1140     */
1141 jsr166 1.27 public void testInvokeAll4() throws Exception {
1142     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1143 dl 1.12 try {
1144     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1145     l.add(new NPETask());
1146     List<Future<String>> result = e.invokeAll(l);
1147     assertEquals(1, result.size());
1148 jsr166 1.27 for (Future<String> future : result) {
1149     try {
1150     future.get();
1151     shouldThrow();
1152     } catch (ExecutionException success) {
1153     Throwable cause = success.getCause();
1154     assertTrue(cause instanceof NullPointerException);
1155     }
1156     }
1157 dl 1.12 } finally {
1158     joinPool(e);
1159     }
1160     }
1161    
1162     /**
1163     * invokeAll(c) returns results of all completed tasks
1164     */
1165 jsr166 1.27 public void testInvokeAll5() throws Exception {
1166     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1167 dl 1.12 try {
1168     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1169     l.add(new StringTask());
1170     l.add(new StringTask());
1171     List<Future<String>> result = e.invokeAll(l);
1172     assertEquals(2, result.size());
1173 jsr166 1.27 for (Future<String> future : result)
1174     assertSame(TEST_STRING, future.get());
1175 dl 1.12 } finally {
1176     joinPool(e);
1177     }
1178     }
1179    
1180    
1181 dl 1.13
1182     /**
1183     * timed invokeAny(null) throws NPE
1184     */
1185 jsr166 1.27 public void testTimedInvokeAny1() throws Exception {
1186     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1187 dl 1.13 try {
1188 jsr166 1.27 e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1189     shouldThrow();
1190 dl 1.13 } catch (NullPointerException success) {
1191     } finally {
1192     joinPool(e);
1193     }
1194     }
1195    
1196     /**
1197     * timed invokeAny(,,null) throws NPE
1198     */
1199 jsr166 1.27 public void testTimedInvokeAnyNullTimeUnit() throws Exception {
1200     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1201 dl 1.13 try {
1202     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1203     l.add(new StringTask());
1204     e.invokeAny(l, MEDIUM_DELAY_MS, null);
1205 jsr166 1.27 shouldThrow();
1206 dl 1.13 } catch (NullPointerException success) {
1207     } finally {
1208     joinPool(e);
1209     }
1210     }
1211    
1212     /**
1213     * timed invokeAny(empty collection) throws IAE
1214     */
1215 jsr166 1.27 public void testTimedInvokeAny2() throws Exception {
1216     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1217 dl 1.13 try {
1218 jsr166 1.27 e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1219     shouldThrow();
1220 dl 1.13 } catch (IllegalArgumentException success) {
1221     } finally {
1222     joinPool(e);
1223     }
1224     }
1225    
1226     /**
1227     * timed invokeAny(c) throws NPE if c has null elements
1228     */
1229 jsr166 1.27 public void testTimedInvokeAny3() throws Exception {
1230 jsr166 1.30 final CountDownLatch latch = new CountDownLatch(1);
1231 jsr166 1.27 ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1232 dl 1.13 try {
1233     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1234 jsr166 1.30 l.add(new Callable<String>() {
1235     public String call() {
1236     try {
1237     latch.await();
1238     } catch (InterruptedException ok) {}
1239     return TEST_STRING;
1240     }});
1241 dl 1.13 l.add(null);
1242 jsr166 1.27 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1243     shouldThrow();
1244 dl 1.13 } catch (NullPointerException success) {
1245     } finally {
1246 jsr166 1.30 latch.countDown();
1247 dl 1.13 joinPool(e);
1248     }
1249     }
1250    
1251     /**
1252     * timed invokeAny(c) throws ExecutionException if no task completes
1253     */
1254 jsr166 1.27 public void testTimedInvokeAny4() throws Exception {
1255     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1256 dl 1.13 try {
1257     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1258     l.add(new NPETask());
1259 jsr166 1.27 e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1260     shouldThrow();
1261 jsr166 1.25 } catch (ExecutionException success) {
1262 jsr166 1.27 assertTrue(success.getCause() instanceof NullPointerException);
1263 dl 1.13 } finally {
1264     joinPool(e);
1265     }
1266     }
1267    
1268     /**
1269     * timed invokeAny(c) returns result of some task
1270     */
1271 jsr166 1.27 public void testTimedInvokeAny5() throws Exception {
1272     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1273 dl 1.13 try {
1274     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1275     l.add(new StringTask());
1276     l.add(new StringTask());
1277 jsr166 1.27 String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1278 dl 1.13 assertSame(TEST_STRING, result);
1279     } finally {
1280     joinPool(e);
1281     }
1282     }
1283    
1284     /**
1285     * timed invokeAll(null) throws NPE
1286     */
1287 jsr166 1.27 public void testTimedInvokeAll1() throws Exception {
1288     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1289 dl 1.13 try {
1290 jsr166 1.27 e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1291     shouldThrow();
1292 dl 1.13 } catch (NullPointerException success) {
1293     } finally {
1294     joinPool(e);
1295     }
1296     }
1297    
1298     /**
1299     * timed invokeAll(,,null) throws NPE
1300     */
1301 jsr166 1.27 public void testTimedInvokeAllNullTimeUnit() throws Exception {
1302     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1303 dl 1.13 try {
1304     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1305     l.add(new StringTask());
1306     e.invokeAll(l, MEDIUM_DELAY_MS, null);
1307 jsr166 1.27 shouldThrow();
1308 dl 1.13 } catch (NullPointerException success) {
1309     } finally {
1310     joinPool(e);
1311     }
1312     }
1313    
1314     /**
1315     * timed invokeAll(empty collection) returns empty collection
1316     */
1317 jsr166 1.27 public void testTimedInvokeAll2() throws InterruptedException {
1318     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1319 dl 1.13 try {
1320 jsr166 1.27 List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1321 dl 1.13 assertTrue(r.isEmpty());
1322     } finally {
1323     joinPool(e);
1324     }
1325     }
1326    
1327     /**
1328     * timed invokeAll(c) throws NPE if c has null elements
1329     */
1330 jsr166 1.27 public void testTimedInvokeAll3() throws Exception {
1331     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1332 dl 1.13 try {
1333     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1334     l.add(new StringTask());
1335     l.add(null);
1336 jsr166 1.27 e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1337     shouldThrow();
1338 dl 1.13 } catch (NullPointerException success) {
1339     } finally {
1340     joinPool(e);
1341     }
1342     }
1343    
1344     /**
1345     * get of element of invokeAll(c) throws exception on failed task
1346     */
1347 jsr166 1.27 public void testTimedInvokeAll4() throws Exception {
1348     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1349 dl 1.13 try {
1350     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1351     l.add(new NPETask());
1352 jsr166 1.27 List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1353 dl 1.13 assertEquals(1, result.size());
1354 jsr166 1.27 for (Future<String> future : result)
1355     future.get();
1356     shouldThrow();
1357 jsr166 1.25 } catch (ExecutionException success) {
1358 jsr166 1.27 assertTrue(success.getCause() instanceof NullPointerException);
1359 dl 1.13 } finally {
1360     joinPool(e);
1361     }
1362     }
1363    
1364     /**
1365     * timed invokeAll(c) returns results of all completed tasks
1366     */
1367 jsr166 1.27 public void testTimedInvokeAll5() throws Exception {
1368     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1369 dl 1.13 try {
1370     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1371     l.add(new StringTask());
1372     l.add(new StringTask());
1373 jsr166 1.27 List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1374 dl 1.13 assertEquals(2, result.size());
1375 jsr166 1.24 for (Iterator<Future<String>> it = result.iterator(); it.hasNext();)
1376 dl 1.13 assertSame(TEST_STRING, it.next().get());
1377     } finally {
1378     joinPool(e);
1379     }
1380     }
1381    
1382     /**
1383     * timed invokeAll(c) cancels tasks not completed by timeout
1384     */
1385 jsr166 1.27 public void testTimedInvokeAll6() throws Exception {
1386     ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1387 dl 1.13 try {
1388     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1389     l.add(new StringTask());
1390 dl 1.14 l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1391 dl 1.16 l.add(new StringTask());
1392 jsr166 1.27 List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1393 dl 1.16 assertEquals(3, result.size());
1394 jsr166 1.24 Iterator<Future<String>> it = result.iterator();
1395 dl 1.13 Future<String> f1 = it.next();
1396     Future<String> f2 = it.next();
1397 dl 1.16 Future<String> f3 = it.next();
1398 dl 1.13 assertTrue(f1.isDone());
1399 dl 1.16 assertTrue(f2.isDone());
1400     assertTrue(f3.isDone());
1401 dl 1.13 assertFalse(f1.isCancelled());
1402     assertTrue(f2.isCancelled());
1403     } finally {
1404     joinPool(e);
1405     }
1406     }
1407    
1408 dl 1.19 /**
1409     * Execution continues if there is at least one thread even if
1410     * thread factory fails to create more
1411     */
1412 jsr166 1.27 public void testFailingThreadFactory() throws InterruptedException {
1413     ExecutorService e = new ThreadPoolExecutor(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1414 dl 1.19 try {
1415     ArrayList<Callable<String>> l = new ArrayList<Callable<String>>();
1416     for (int k = 0; k < 100; ++k) {
1417     e.execute(new NoOpRunnable());
1418     }
1419     Thread.sleep(LONG_DELAY_MS);
1420     } finally {
1421     joinPool(e);
1422     }
1423     }
1424 dl 1.21
1425     /**
1426     * allowsCoreThreadTimeOut is by default false.
1427     */
1428     public void testAllowsCoreThreadTimeOut() {
1429 jsr166 1.27 ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1430 dl 1.21 assertFalse(tpe.allowsCoreThreadTimeOut());
1431     joinPool(tpe);
1432     }
1433    
1434     /**
1435     * allowCoreThreadTimeOut(true) causes idle threads to time out
1436     */
1437 jsr166 1.27 public void testAllowCoreThreadTimeOut_true() throws InterruptedException {
1438     ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1439 dl 1.21 tpe.allowCoreThreadTimeOut(true);
1440     tpe.execute(new NoOpRunnable());
1441     try {
1442     Thread.sleep(MEDIUM_DELAY_MS);
1443     assertEquals(0, tpe.getPoolSize());
1444     } finally {
1445     joinPool(tpe);
1446     }
1447     }
1448    
1449     /**
1450     * allowCoreThreadTimeOut(false) causes idle threads not to time out
1451     */
1452 jsr166 1.27 public void testAllowCoreThreadTimeOut_false() throws InterruptedException {
1453     ThreadPoolExecutor tpe = new ThreadPoolExecutor(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1454 dl 1.21 tpe.allowCoreThreadTimeOut(false);
1455     tpe.execute(new NoOpRunnable());
1456     try {
1457     Thread.sleep(MEDIUM_DELAY_MS);
1458     assertTrue(tpe.getPoolSize() >= 1);
1459     } finally {
1460     joinPool(tpe);
1461     }
1462     }
1463    
1464 dl 1.23 /**
1465     * execute allows the same task to be submitted multiple times, even
1466     * if rejected
1467     */
1468 jsr166 1.27 public void testRejectedRecycledTask() throws InterruptedException {
1469 dl 1.23 final int nTasks = 1000;
1470     final AtomicInteger nRun = new AtomicInteger(0);
1471     final Runnable recycledTask = new Runnable() {
1472     public void run() {
1473     nRun.getAndIncrement();
1474     } };
1475 jsr166 1.24 final ThreadPoolExecutor p =
1476     new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
1477 dl 1.23 new ArrayBlockingQueue(30));
1478     try {
1479     for (int i = 0; i < nTasks; ++i) {
1480     for (;;) {
1481     try {
1482     p.execute(recycledTask);
1483     break;
1484     }
1485     catch (RejectedExecutionException ignore) {
1486     }
1487     }
1488     }
1489     Thread.sleep(5000); // enough time to run all tasks
1490     assertEquals(nRun.get(), nTasks);
1491     } finally {
1492     p.shutdown();
1493     }
1494     }
1495 jsr166 1.24
1496 dl 1.1 }