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

Diff Legend

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