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.7 by dl, Fri Sep 26 15:33:14 2003 UTC vs.
Revision 1.23 by dl, Tue Aug 23 12:50:00 2005 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) {
#	Line 17 | Line 19 | public class ThreadPoolExecutorTest exte
19		return new TestSuite(ThreadPoolExecutorTest.class);
20		}
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	+	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	+
48
49		/**
50	<	*   execute successfully executes a runnable
50	>	*  execute successfully executes a runnable
51		*/
52		public void testExecute() {
53	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
53	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
54		try {
55		p1.execute(new Runnable() {
56		public void run() {
#	Line 45 | Line 73 | public class ThreadPoolExecutorTest exte
73		*  thread becomes active
74		*/
75		public void testGetActiveCount() {
76	<	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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 {
#	Line 56 | Line 84 | public class ThreadPoolExecutorTest exte
84		assertEquals(1, p2.getActiveCount());
85		joinPool(p2);
86		}
87	+
88	+	/**
89	+	*  prestartCoreThread starts a thread if under corePoolSize, else doesn't
90	+	*/
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, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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(MEDIUM_DELAY_MS);
125	>	Thread.sleep(SMALL_DELAY_MS);
126		} catch(Exception e){
127		unexpectedException();
128		}
129		assertEquals(1, p2.getCompletedTaskCount());
130	<	p2.shutdown();
130	>	try { p2.shutdown(); } catch(SecurityException ok) { return; }
131		joinPool(p2);
132		}
133
#	Line 79 | Line 135 | public class ThreadPoolExecutorTest exte
135		*   getCorePoolSize returns size given in constructor if not otherwise set
136		*/
137		public void testGetCorePoolSize() {
138	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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		}
#	Line 92 | Line 148 | public class ThreadPoolExecutorTest exte
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	+	}
187	+	}
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	+	* setRejectedExecutionHandler sets the handler returned by
201	+	* getRejectedExecutionHandler
202	+	*/
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	+
211	+
212	+	/**
213	+	* setRejectedExecutionHandler(null) throws NPE
214	+	*/
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	+
226
227		/**
228		*   getLargestPoolSize increases, but doesn't overestimate, when
229		*   multiple threads active
230		*/
231		public void testGetLargestPoolSize() {
232	<	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
232	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
233		try {
234		assertEquals(0, p2.getLargestPoolSize());
235		p2.execute(new MediumRunnable());
#	Line 116 | Line 247 | public class ThreadPoolExecutorTest exte
247		*   otherwise set
248		*/
249		public void testGetMaximumPoolSize() {
250	<	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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		}
#	Line 126 | Line 257 | public class ThreadPoolExecutorTest exte
257		*   become active
258		*/
259		public void testGetPoolSize() {
260	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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());
#	Line 134 | Line 265 | public class ThreadPoolExecutorTest exte
265		}
266
267		/**
268	<	*   getTaskCount increases, but doesn't overestimate, when tasks submitted
268	>	*  getTaskCount increases, but doesn't overestimate, when tasks submitted
269		*/
270		public void testGetTaskCount() {
271	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
271	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
272		try {
273		assertEquals(0, p1.getTaskCount());
274		p1.execute(new MediumRunnable());
#	Line 154 | Line 285 | public class ThreadPoolExecutorTest exte
285		*/
286		public void testIsShutdown() {
287
288	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
288	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
289		assertFalse(p1.isShutdown());
290	<	p1.shutdown();
290	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
291		assertTrue(p1.isShutdown());
292		joinPool(p1);
293		}
#	Line 166 | Line 297 | public class ThreadPoolExecutorTest exte
297		*  isTerminated is false before termination, true after
298		*/
299		public void testIsTerminated() {
300	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
300	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
301		assertFalse(p1.isTerminated());
302		try {
303		p1.execute(new MediumRunnable());
304		} finally {
305	<	p1.shutdown();
305	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
306		}
307		try {
308		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 185 | Line 316 | public class ThreadPoolExecutorTest exte
316		*  isTerminating is not true when running or when terminated
317		*/
318		public void testIsTerminating() {
319	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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	<	p1.shutdown();
325	>	try { p1.shutdown(); } catch(SecurityException ok) { return; }
326		}
327		try {
328		assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
#	Line 203 | Line 334 | public class ThreadPoolExecutorTest exte
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, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
397	<	CancellableTask[] tasks = new CancellableTask[5];
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 CancellableTask(new MediumPossiblyInterruptedRunnable());
399	>	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
400		p1.execute(tasks[i]);
401		}
402		tasks[4].cancel(true);
#	Line 224 | Line 411 | public class ThreadPoolExecutorTest exte
411		*  shutDownNow returns a list containing tasks that were not run
412		*/
413		public void testShutDownNow() {
414	<	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
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		p1.execute(new MediumPossiblyInterruptedRunnable());
419		}
420		finally {
421	<	l = p1.shutdownNow();
421	>	try {
422	>	l = p1.shutdownNow();
423	>	} catch (SecurityException ok) { return; }
424	>
425		}
426		assertTrue(p1.isShutdown());
427		assertTrue(l.size() <= 4);
#	Line 298 | Line 488 | public class ThreadPoolExecutorTest exte
488		/**
489		* Constructor throws if workQueue is set to null
490		*/
491	<	public void testNullPointerException() {
491	>	public void testConstructorNullPointerException() {
492		try {
493	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null);
493	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null);
494		shouldThrow();
495		}
496		catch (NullPointerException success){}
#	Line 323 | Line 513 | public class ThreadPoolExecutorTest exte
513		*/
514		public void testConstructor7() {
515		try {
516	<	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
516	>	new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
517		shouldThrow();
518		}
519		catch (IllegalArgumentException success){}
#	Line 334 | Line 524 | public class ThreadPoolExecutorTest exte
524		*/
525		public void testConstructor8() {
526		try {
527	<	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
527	>	new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
528		shouldThrow();
529		}
530		catch (IllegalArgumentException success){}
#	Line 356 | Line 546 | public class ThreadPoolExecutorTest exte
546		*/
547		public void testConstructor10() {
548		try {
549	<	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
549	>	new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
550		shouldThrow();
551		}
552		catch (IllegalArgumentException success){}
#	Line 365 | Line 555 | public class ThreadPoolExecutorTest exte
555		/**
556		* Constructor throws if workQueue is set to null
557		*/
558	<	public void testNullPointerException2() {
558	>	public void testConstructorNullPointerException2() {
559		try {
560	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
560	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
561		shouldThrow();
562		}
563		catch (NullPointerException success){}
#	Line 376 | Line 566 | public class ThreadPoolExecutorTest exte
566		/**
567		* Constructor throws if threadFactory is set to null
568		*/
569	<	public void testNullPointerException3() {
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);
572	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
573		shouldThrow();
574		}
575		catch (NullPointerException success){}
#	Line 391 | Line 581 | public class ThreadPoolExecutorTest exte
581		*/
582		public void testConstructor11() {
583		try {
584	<	new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
584	>	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
585		shouldThrow();
586		}
587		catch (IllegalArgumentException success){}
#	Line 402 | Line 592 | public class ThreadPoolExecutorTest exte
592		*/
593		public void testConstructor12() {
594		try {
595	<	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
595	>	new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
596		shouldThrow();
597		}
598		catch (IllegalArgumentException success){}
#	Line 413 | Line 603 | public class ThreadPoolExecutorTest exte
603		*/
604		public void testConstructor13() {
605		try {
606	<	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
606	>	new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
607		shouldThrow();
608		}
609		catch (IllegalArgumentException success){}
#	Line 435 | Line 625 | public class ThreadPoolExecutorTest exte
625		*/
626		public void testConstructor15() {
627		try {
628	<	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
628	>	new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
629		shouldThrow();
630		}
631		catch (IllegalArgumentException success){}
#	Line 444 | Line 634 | public class ThreadPoolExecutorTest exte
634		/**
635		* Constructor throws if workQueue is set to null
636		*/
637	<	public void testNullPointerException4() {
637	>	public void testConstructorNullPointerException4() {
638		try {
639	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
639	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
640		shouldThrow();
641		}
642		catch (NullPointerException success){}
#	Line 455 | Line 645 | public class ThreadPoolExecutorTest exte
645		/**
646		* Constructor throws if handler is set to null
647		*/
648	<	public void testNullPointerException5() {
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);
651	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
652		shouldThrow();
653		}
654		catch (NullPointerException success){}
#	Line 470 | Line 660 | public class ThreadPoolExecutorTest exte
660		*/
661		public void testConstructor16() {
662		try {
663	<	new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
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){}
#	Line 481 | Line 671 | public class ThreadPoolExecutorTest exte
671		*/
672		public void testConstructor17() {
673		try {
674	<	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
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){}
#	Line 492 | Line 682 | public class ThreadPoolExecutorTest exte
682		*/
683		public void testConstructor18() {
684		try {
685	<	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
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){}
#	Line 514 | Line 704 | public class ThreadPoolExecutorTest exte
704		*/
705		public void testConstructor20() {
706		try {
707	<	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
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){}
#	Line 523 | Line 713 | public class ThreadPoolExecutorTest exte
713		/**
714		* Constructor throws if workQueue is set to null
715		*/
716	<	public void testNullPointerException6() {
716	>	public void testConstructorNullPointerException6() {
717		try {
718	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
718	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
719		shouldThrow();
720		}
721		catch (NullPointerException success){}
#	Line 534 | Line 724 | public class ThreadPoolExecutorTest exte
724		/**
725		* Constructor throws if handler is set to null
726		*/
727	<	public void testNullPointerException7() {
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 SimpleThreadFactory(),r);
730	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
731		shouldThrow();
732		}
733		catch (NullPointerException success){}
#	Line 546 | Line 736 | public class ThreadPoolExecutorTest exte
736		/**
737		* Constructor throws if ThreadFactory is set top null
738		*/
739	<	public void testNullPointerException8() {
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 NoOpREHandler());
742	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
743		shouldThrow();
744		}
745		catch (NullPointerException successdn8){}
#	Line 557 | Line 747 | public class ThreadPoolExecutorTest exte
747
748
749		/**
560	–	*  execute throws RejectedExecutionException if shutdown
561	–	*/
562	–	public void testRejectedExecutionException() {
563	–	ThreadPoolExecutor tpe = null;
564	–	try {
565	–	tpe = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
566	–	} catch(Exception e){}
567	–	tpe.shutdown();
568	–	try {
569	–	tpe.execute(new NoOpRunnable());
570	–	shouldThrow();
571	–	} catch(RejectedExecutionException success){}
572	–
573	–	joinPool(tpe);
574	–	}
575	–
576	–	/**
750		*  execute throws RejectedExecutionException
751		*  if saturated.
752		*/
753		public void testSaturatedExecute() {
754	<	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
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){
#	Line 590 | Line 763 | public class ThreadPoolExecutorTest exte
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	+	}
791	+	}
792	+
793	+	/**
794	+	*  executor using DiscardPolicy drops task if saturated.
795	+	*/
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	+	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,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
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){}
#	Line 604 | Line 929 | public class ThreadPoolExecutorTest exte
929		}
930
931		/**
932	<	*  setCorePoolSize of netaitev value throws IllegalArgumentException
932	>	*  setCorePoolSize of negative value throws IllegalArgumentException
933		*/
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));
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		shouldThrow();
942		} catch(IllegalArgumentException success){
943		} finally {
944	<	tpe.shutdown();
944	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
945		}
946		joinPool(tpe);
947		}
#	Line 628 | Line 953 | public class ThreadPoolExecutorTest exte
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));
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		shouldThrow();
961		} catch(IllegalArgumentException success){
962		} finally {
963	<	tpe.shutdown();
963	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
964		}
965		joinPool(tpe);
966		}
#	Line 647 | Line 972 | public class ThreadPoolExecutorTest exte
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));
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		shouldThrow();
980		} catch(IllegalArgumentException success){
981		} finally {
982	<	tpe.shutdown();
982	>	try { tpe.shutdown(); } catch(SecurityException ok) { return; }
983		}
984		joinPool(tpe);
985		}
#	Line 667 | Line 992 | public class ThreadPoolExecutorTest exte
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));
995	>	tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
996		} catch(Exception e){}
997
998		try {
#	Line 675 | Line 1000 | public class ThreadPoolExecutorTest exte
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