ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorTest.java

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.3 by dl, Sun Sep 14 20:42:41 2003 UTC vs.
Revision 1.16 by dl, Sun Dec 28 21:56:18 2003 UTC

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

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines