ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorTest.java
Revision: 1.17
Committed: Tue Jan 20 20:20:56 2004 UTC (20 years, 4 months ago) by dl
Branch: MAIN
Changes since 1.16: +18 -25 lines
Log Message: 
Don't fail if test harness doesn't have sufficient permissions

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