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.9 by dl, Sun Oct 5 23:55:03 2003 UTC

#	Line 17 | Line 17 | public class ThreadPoolExecutorTest exte
17		return new TestSuite(ThreadPoolExecutorTest.class);
18		}
19
20	<	/**
21	<	* For use as ThreadFactory in constructors
22	<	*/
23	<	static class MyThreadFactory implements ThreadFactory{
24	<	public Thread newThread(Runnable r){
25	<	return new Thread(r);
26	<	}
20	>	static class ExtendedTPE extends ThreadPoolExecutor {
21	>	volatile boolean beforeCalled = false;
22	>	volatile boolean afterCalled = false;
23	>	volatile boolean terminatedCalled = false;
24	>	public ExtendedTPE() {
25	>	super(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());
26	>	}
27	>	protected void beforeExecute(Thread t, Runnable r) {
28	>	beforeCalled = true;
29	>	}
30	>	protected void afterExecute(Runnable r, Throwable t) {
31	>	afterCalled = true;
32	>	}
33	>	protected void terminated() {
34	>	terminatedCalled = true;
35	>	}
36		}
37
38		/**
39	<	* For use as RejectedExecutionHandler in constructors
39	>	*  execute successfully executes a runnable
40		*/
41	<	static class MyREHandler implements RejectedExecutionHandler{
42	<	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){}
34	<	}
35	<
36	<	/**
37	<	*   execute successfully executes a runnable
38	<	*/
39	<	public void testExecute(){
40	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
41	>	public void testExecute() {
42	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
43		try {
44	<	one.execute(new Runnable(){
45	<	public void run(){
46	<	try{
44	>	p1.execute(new Runnable() {
45	>	public void run() {
46	>	try {
47		Thread.sleep(SHORT_DELAY_MS);
48		} catch(InterruptedException e){
49	<	fail("unexpected exception");
49	>	threadUnexpectedException();
50		}
51		}
52		});
53		Thread.sleep(SMALL_DELAY_MS);
54		} catch(InterruptedException e){
55	<	fail("unexpected exception");
55	>	unexpectedException();
56		}
57	<	joinPool(one);
57	>	joinPool(p1);
58		}
59
60		/**
61	<	*   getActiveCount gives correct values
61	>	*  getActiveCount increases but doesn't overestimate, when a
62	>	*  thread becomes active
63		*/
64	<	public void testGetActiveCount(){
65	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
66	<	assertEquals(0, two.getActiveCount());
67	<	two.execute(new MediumRunnable());
68	<	try{
64	>	public void testGetActiveCount() {
65	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
66	>	assertEquals(0, p2.getActiveCount());
67	>	p2.execute(new MediumRunnable());
68	>	try {
69		Thread.sleep(SHORT_DELAY_MS);
70		} catch(Exception e){
71	<	fail("unexpected exception");
71	>	unexpectedException();
72		}
73	<	assertEquals(1, two.getActiveCount());
74	<	joinPool(two);
73	>	assertEquals(1, p2.getActiveCount());
74	>	joinPool(p2);
75	>	}
76	>
77	>	/**
78	>	*  prestartCoreThread starts a thread if under corePoolSize, else doesn't
79	>	*/
80	>	public void testPrestartCoreThread() {
81	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
82	>	assertEquals(0, p2.getPoolSize());
83	>	assertTrue(p2.prestartCoreThread());
84	>	assertEquals(1, p2.getPoolSize());
85	>	assertTrue(p2.prestartCoreThread());
86	>	assertEquals(2, p2.getPoolSize());
87	>	assertFalse(p2.prestartCoreThread());
88	>	assertEquals(2, p2.getPoolSize());
89	>	joinPool(p2);
90	>	}
91	>
92	>	/**
93	>	*  prestartAllCoreThreads starts all corePoolSize threads
94	>	*/
95	>	public void testPrestartAllCoreThreads() {
96	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
97	>	assertEquals(0, p2.getPoolSize());
98	>	p2.prestartAllCoreThreads();
99	>	assertEquals(2, p2.getPoolSize());
100	>	p2.prestartAllCoreThreads();
101	>	assertEquals(2, p2.getPoolSize());
102	>	joinPool(p2);
103		}
104
105		/**
106	<	*   getCompleteTaskCount gives correct values
106	>	*   getCompletedTaskCount increases, but doesn't overestimate,
107	>	*   when tasks complete
108		*/
109	<	public void testGetCompletedTaskCount(){
110	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
111	<	assertEquals(0, two.getCompletedTaskCount());
112	<	two.execute(new ShortRunnable());
113	<	try{
114	<	Thread.sleep(MEDIUM_DELAY_MS);
109	>	public void testGetCompletedTaskCount() {
110	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
111	>	assertEquals(0, p2.getCompletedTaskCount());
112	>	p2.execute(new ShortRunnable());
113	>	try {
114	>	Thread.sleep(SMALL_DELAY_MS);
115		} catch(Exception e){
116	<	fail("unexpected exception");
116	>	unexpectedException();
117		}
118	<	assertEquals(1, two.getCompletedTaskCount());
119	<	two.shutdown();
120	<	joinPool(two);
118	>	assertEquals(1, p2.getCompletedTaskCount());
119	>	p2.shutdown();
120	>	joinPool(p2);
121		}
122
123		/**
124	<	*   getCorePoolSize gives correct values
124	>	*   getCorePoolSize returns size given in constructor if not otherwise set
125		*/
126	<	public void testGetCorePoolSize(){
127	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
128	<	assertEquals(1, one.getCorePoolSize());
129	<	joinPool(one);
126	>	public void testGetCorePoolSize() {
127	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
128	>	assertEquals(1, p1.getCorePoolSize());
129	>	joinPool(p1);
130		}
131
132		/**
133	<	*   getKeepAliveTime gives correct values
133	>	*   getKeepAliveTime returns value given in constructor if not otherwise set
134	>	*/
135	>	public void testGetKeepAliveTime() {
136	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
137	>	assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS));
138	>	joinPool(p2);
139	>	}
140	>
141	>
142	>	/**
143	>	* getThreadFactory returns factory in constructor if not set
144		*/
145	<	public void testGetKeepAliveTime(){
146	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
147	<	assertEquals(1, two.getKeepAliveTime(TimeUnit.SECONDS));
148	<	joinPool(two);
145	>	public void testGetThreadFactory() {
146	>	ThreadFactory tf = new SimpleThreadFactory();
147	>	ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler());
148	>	assertSame(tf, p.getThreadFactory());
149	>	p.shutdown();
150	>	joinPool(p);
151		}
152	+
153	+	/**
154	+	* setThreadFactory sets the thread factory returned by getThreadFactory
155	+	*/
156	+	public void testSetThreadFactory() {
157	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
158	+	ThreadFactory tf = new SimpleThreadFactory();
159	+	p.setThreadFactory(tf);
160	+	assertSame(tf, p.getThreadFactory());
161	+	p.shutdown();
162	+	joinPool(p);
163	+	}
164	+
165	+
166	+	/**
167	+	* setThreadFactory(null) throws NPE
168	+	*/
169	+	public void testSetThreadFactoryNull() {
170	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
171	+	try {
172	+	p.setThreadFactory(null);
173	+	shouldThrow();
174	+	} catch (NullPointerException success) {
175	+	} finally {
176	+	joinPool(p);
177	+	}
178	+	}
179	+
180	+
181	+	/**
182	+	* getRejectedExecutionHandler returns handler in constructor if not set
183	+	*/
184	+	public void testGetRejectedExecutionHandler() {
185	+	RejectedExecutionHandler h = new NoOpREHandler();
186	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h);
187	+	assertSame(h, p.getRejectedExecutionHandler());
188	+	p.shutdown();
189	+	joinPool(p);
190	+	}
191	+
192	+	/**
193	+	* setRejectedExecutionHandler sets the handler returned by
194	+	* getRejectedExecutionHandler
195	+	*/
196	+	public void testSetRejectedExecutionHandler() {
197	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
198	+	RejectedExecutionHandler h = new NoOpREHandler();
199	+	p.setRejectedExecutionHandler(h);
200	+	assertSame(h, p.getRejectedExecutionHandler());
201	+	p.shutdown();
202	+	joinPool(p);
203	+	}
204	+
205	+
206	+	/**
207	+	* setRejectedExecutionHandler(null) throws NPE
208	+	*/
209	+	public void testSetRejectedExecutionHandlerNull() {
210	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
211	+	try {
212	+	p.setRejectedExecutionHandler(null);
213	+	shouldThrow();
214	+	} catch (NullPointerException success) {
215	+	} finally {
216	+	joinPool(p);
217	+	}
218	+	}
219	+
220
221		/**
222	<	*   getLargestPoolSize gives correct values
222	>	*   getLargestPoolSize increases, but doesn't overestimate, when
223	>	*   multiple threads active
224		*/
225	<	public void testGetLargestPoolSize(){
226	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
225	>	public void testGetLargestPoolSize() {
226	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
227		try {
228	<	assertEquals(0, two.getLargestPoolSize());
229	<	two.execute(new MediumRunnable());
230	<	two.execute(new MediumRunnable());
228	>	assertEquals(0, p2.getLargestPoolSize());
229	>	p2.execute(new MediumRunnable());
230	>	p2.execute(new MediumRunnable());
231		Thread.sleep(SHORT_DELAY_MS);
232	<	assertEquals(2, two.getLargestPoolSize());
232	>	assertEquals(2, p2.getLargestPoolSize());
233		} catch(Exception e){
234	<	fail("unexpected exception");
234	>	unexpectedException();
235		}
236	<	joinPool(two);
236	>	joinPool(p2);
237		}
238
239		/**
240	<	*   getMaximumPoolSize gives correct values
240	>	*   getMaximumPoolSize returns value given in constructor if not
241	>	*   otherwise set
242		*/
243	<	public void testGetMaximumPoolSize(){
244	<	ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
245	<	assertEquals(2, two.getMaximumPoolSize());
246	<	joinPool(two);
243	>	public void testGetMaximumPoolSize() {
244	>	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
245	>	assertEquals(2, p2.getMaximumPoolSize());
246	>	joinPool(p2);
247		}
248
249		/**
250	<	*   getPoolSize gives correct values
250	>	*   getPoolSize increases, but doesn't overestimate, when threads
251	>	*   become active
252		*/
253	<	public void testGetPoolSize(){
254	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
255	<	assertEquals(0, one.getPoolSize());
256	<	one.execute(new MediumRunnable());
257	<	assertEquals(1, one.getPoolSize());
258	<	joinPool(one);
253	>	public void testGetPoolSize() {
254	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
255	>	assertEquals(0, p1.getPoolSize());
256	>	p1.execute(new MediumRunnable());
257	>	assertEquals(1, p1.getPoolSize());
258	>	joinPool(p1);
259		}
260
261		/**
262	<	*   getTaskCount gives correct values
262	>	*  getTaskCount increases, but doesn't overestimate, when tasks submitted
263		*/
264	<	public void testGetTaskCount(){
265	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
264	>	public void testGetTaskCount() {
265	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
266		try {
267	<	assertEquals(0, one.getTaskCount());
268	<	for(int i = 0; i < 5; i++)
154	<	one.execute(new MediumRunnable());
267	>	assertEquals(0, p1.getTaskCount());
268	>	p1.execute(new MediumRunnable());
269		Thread.sleep(SHORT_DELAY_MS);
270	<	assertEquals(5, one.getTaskCount());
270	>	assertEquals(1, p1.getTaskCount());
271		} catch(Exception e){
272	<	fail("unexpected exception");
272	>	unexpectedException();
273		}
274	<	joinPool(one);
274	>	joinPool(p1);
275		}
276
277		/**
278	<	*   isShutDown gives correct values
278	>	*   isShutDown is false before shutdown, true after
279		*/
280	<	public void testIsShutdown(){
280	>	public void testIsShutdown() {
281
282	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
283	<	assertFalse(one.isShutdown());
284	<	one.shutdown();
285	<	assertTrue(one.isShutdown());
286	<	joinPool(one);
282	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
283	>	assertFalse(p1.isShutdown());
284	>	p1.shutdown();
285	>	assertTrue(p1.isShutdown());
286	>	joinPool(p1);
287		}
288
289
290		/**
291	<	*   isTerminated gives correct values
178	<	*  Makes sure termination does not take an innapropriate
179	<	*  amount of time
291	>	*  isTerminated is false before termination, true after
292		*/
293	<	public void testIsTerminated(){
294	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
293	>	public void testIsTerminated() {
294	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
295	>	assertFalse(p1.isTerminated());
296		try {
297	<	one.execute(new MediumRunnable());
297	>	p1.execute(new MediumRunnable());
298		} finally {
299	<	one.shutdown();
299	>	p1.shutdown();
300		}
301		try {
302	<	assertTrue(one.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
303	<	assertTrue(one.isTerminated());
302	>	assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
303	>	assertTrue(p1.isTerminated());
304	>	} catch(Exception e){
305	>	unexpectedException();
306	>	}
307	>	}
308	>
309	>	/**
310	>	*  isTerminating is not true when running or when terminated
311	>	*/
312	>	public void testIsTerminating() {
313	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
314	>	assertFalse(p1.isTerminating());
315	>	try {
316	>	p1.execute(new SmallRunnable());
317	>	assertFalse(p1.isTerminating());
318	>	} finally {
319	>	p1.shutdown();
320	>	}
321	>	try {
322	>	assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
323	>	assertTrue(p1.isTerminated());
324	>	assertFalse(p1.isTerminating());
325		} catch(Exception e){
326	<	fail("unexpected exception");
326	>	unexpectedException();
327		}
328		}
329
330		/**
331	<	*   purge correctly removes cancelled tasks
332	<	*  from the queue
331	>	* getQueue returns the work queue, which contains queued tasks
332	>	*/
333	>	public void testGetQueue() {
334	>	BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
335	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
336	>	CancellableTask[] tasks = new CancellableTask[5];
337	>	for(int i = 0; i < 5; i++){
338	>	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
339	>	p1.execute(tasks[i]);
340	>	}
341	>	try {
342	>	Thread.sleep(SHORT_DELAY_MS);
343	>	BlockingQueue<Runnable> wq = p1.getQueue();
344	>	assertSame(q, wq);
345	>	assertFalse(wq.contains(tasks[0]));
346	>	assertTrue(wq.contains(tasks[4]));
347	>	p1.shutdownNow();
348	>	} catch(Exception e) {
349	>	unexpectedException();
350	>	} finally {
351	>	joinPool(p1);
352	>	}
353	>	}
354	>
355	>	/**
356	>	* remove(task) removes queued task, and fails to remove active task
357		*/
358	<	public void testPurge(){
359	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
358	>	public void testRemove() {
359	>	BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
360	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q);
361		CancellableTask[] tasks = new CancellableTask[5];
362		for(int i = 0; i < 5; i++){
363		tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
364	<	one.execute(tasks[i]);
364	>	p1.execute(tasks[i]);
365	>	}
366	>	try {
367	>	Thread.sleep(SHORT_DELAY_MS);
368	>	assertFalse(p1.remove(tasks[0]));
369	>	assertTrue(q.contains(tasks[4]));
370	>	assertTrue(q.contains(tasks[3]));
371	>	assertTrue(p1.remove(tasks[4]));
372	>	assertFalse(p1.remove(tasks[4]));
373	>	assertFalse(q.contains(tasks[4]));
374	>	assertTrue(q.contains(tasks[3]));
375	>	assertTrue(p1.remove(tasks[3]));
376	>	assertFalse(q.contains(tasks[3]));
377	>	p1.shutdownNow();
378	>	} catch(Exception e) {
379	>	unexpectedException();
380	>	} finally {
381	>	joinPool(p1);
382	>	}
383	>	}
384	>
385	>	/**
386	>	*   purge removes cancelled tasks from the queue
387	>	*/
388	>	public void testPurge() {
389	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
390	>	CancellableTask[] tasks = new CancellableTask[5];
391	>	for(int i = 0; i < 5; i++){
392	>	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
393	>	p1.execute(tasks[i]);
394		}
395		tasks[4].cancel(true);
396		tasks[3].cancel(true);
397	<	one.purge();
398	<	long count = one.getTaskCount();
397	>	p1.purge();
398	>	long count = p1.getTaskCount();
399		assertTrue(count >= 2 && count < 5);
400	<	joinPool(one);
400	>	p1.shutdownNow();
401	>	joinPool(p1);
402		}
403
404		/**
405	<	*   shutDownNow returns a list
217	<	*  containing the correct number of elements
405	>	*  shutDownNow returns a list containing tasks that were not run
406		*/
407	<	public void testShutDownNow(){
408	<	ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
407	>	public void testShutDownNow() {
408	>	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
409		List l;
410		try {
411		for(int i = 0; i < 5; i++)
412	<	one.execute(new MediumPossiblyInterruptedRunnable());
412	>	p1.execute(new MediumPossiblyInterruptedRunnable());
413		}
414		finally {
415	<	l = one.shutdownNow();
415	>	l = p1.shutdownNow();
416		}
417	<	assertTrue(one.isShutdown());
417	>	assertTrue(p1.isShutdown());
418		assertTrue(l.size() <= 4);
419		}
420
421		// Exception Tests
422
423
424	<	/** Throws if corePoolSize argument is less than zero */
424	>	/**
425	>	* Constructor throws if corePoolSize argument is less than zero
426	>	*/
427		public void testConstructor1() {
428	<	try{
428	>	try {
429		new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
430	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
430	>	shouldThrow();
431		}
432		catch (IllegalArgumentException success){}
433		}
434
435	<	/** Throws if maximumPoolSize is less than zero */
435	>	/**
436	>	* Constructor throws if maximumPoolSize is less than zero
437	>	*/
438		public void testConstructor2() {
439	<	try{
439	>	try {
440		new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
441	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
441	>	shouldThrow();
442		}
443		catch (IllegalArgumentException success){}
444		}
445
446	<	/** Throws if maximumPoolSize is equal to zero */
446	>	/**
447	>	* Constructor throws if maximumPoolSize is equal to zero
448	>	*/
449		public void testConstructor3() {
450	<	try{
450	>	try {
451		new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
452	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
452	>	shouldThrow();
453		}
454		catch (IllegalArgumentException success){}
455		}
456
457	<	/** Throws if keepAliveTime is less than zero */
457	>	/**
458	>	* Constructor throws if keepAliveTime is less than zero
459	>	*/
460		public void testConstructor4() {
461	<	try{
461	>	try {
462		new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
463	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
463	>	shouldThrow();
464		}
465		catch (IllegalArgumentException success){}
466		}
467
468	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
468	>	/**
469	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
470	>	*/
471		public void testConstructor5() {
472	<	try{
472	>	try {
473		new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
474	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
474	>	shouldThrow();
475		}
476		catch (IllegalArgumentException success){}
477		}
478
479	<	/** Throws if workQueue is set to null */
480	<	public void testNullPointerException() {
481	<	try{
482	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null);
483	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
479	>	/**
480	>	* Constructor throws if workQueue is set to null
481	>	*/
482	>	public void testConstructorNullPointerException() {
483	>	try {
484	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null);
485	>	shouldThrow();
486		}
487		catch (NullPointerException success){}
488		}
489
490
491
492	<	/** Throws if corePoolSize argument is less than zero */
492	>	/**
493	>	* Constructor throws if corePoolSize argument is less than zero
494	>	*/
495		public void testConstructor6() {
496	<	try{
497	<	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
498	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
496	>	try {
497	>	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
498	>	shouldThrow();
499		} catch (IllegalArgumentException success){}
500		}
501
502	<	/** Throws if maximumPoolSize is less than zero */
502	>	/**
503	>	* Constructor throws if maximumPoolSize is less than zero
504	>	*/
505		public void testConstructor7() {
506	<	try{
507	<	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
508	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
506	>	try {
507	>	new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
508	>	shouldThrow();
509		}
510		catch (IllegalArgumentException success){}
511		}
512
513	<	/** Throws if maximumPoolSize is equal to zero */
513	>	/**
514	>	* Constructor throws if maximumPoolSize is equal to zero
515	>	*/
516		public void testConstructor8() {
517	<	try{
518	<	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
519	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
517	>	try {
518	>	new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
519	>	shouldThrow();
520		}
521		catch (IllegalArgumentException success){}
522		}
523
524	<	/** Throws if keepAliveTime is less than zero */
524	>	/**
525	>	* Constructor throws if keepAliveTime is less than zero
526	>	*/
527		public void testConstructor9() {
528	<	try{
529	<	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
530	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
528	>	try {
529	>	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
530	>	shouldThrow();
531		}
532		catch (IllegalArgumentException success){}
533		}
534
535	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
535	>	/**
536	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
537	>	*/
538		public void testConstructor10() {
539	<	try{
540	<	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
541	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
539	>	try {
540	>	new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
541	>	shouldThrow();
542		}
543		catch (IllegalArgumentException success){}
544		}
545
546	<	/** Throws if workQueue is set to null */
547	<	public void testNullPointerException2() {
548	<	try{
549	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory());
550	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
546	>	/**
547	>	* Constructor throws if workQueue is set to null
548	>	*/
549	>	public void testConstructorNullPointerException2() {
550	>	try {
551	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory());
552	>	shouldThrow();
553		}
554		catch (NullPointerException success){}
555		}
556
557	<	/** Throws if threadFactory is set to null */
558	<	public void testNullPointerException3() {
559	<	try{
557	>	/**
558	>	* Constructor throws if threadFactory is set to null
559	>	*/
560	>	public void testConstructorNullPointerException3() {
561	>	try {
562		ThreadFactory f = null;
563	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
564	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
563	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
564	>	shouldThrow();
565		}
566		catch (NullPointerException success){}
567		}
568
569
570	<	/** Throws if corePoolSize argument is less than zero */
570	>	/**
571	>	* Constructor throws if corePoolSize argument is less than zero
572	>	*/
573		public void testConstructor11() {
574	<	try{
575	<	new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
576	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
574	>	try {
575	>	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
576	>	shouldThrow();
577		}
578		catch (IllegalArgumentException success){}
579		}
580
581	<	/** Throws if maximumPoolSize is less than zero */
581	>	/**
582	>	* Constructor throws if maximumPoolSize is less than zero
583	>	*/
584		public void testConstructor12() {
585	<	try{
586	<	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
587	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
585	>	try {
586	>	new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
587	>	shouldThrow();
588		}
589		catch (IllegalArgumentException success){}
590		}
591
592	<	/** Throws if maximumPoolSize is equal to zero */
592	>	/**
593	>	* Constructor throws if maximumPoolSize is equal to zero
594	>	*/
595		public void testConstructor13() {
596	<	try{
597	<	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
598	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
596	>	try {
597	>	new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
598	>	shouldThrow();
599		}
600		catch (IllegalArgumentException success){}
601		}
602
603	<	/** Throws if keepAliveTime is less than zero */
603	>	/**
604	>	* Constructor throws if keepAliveTime is less than zero
605	>	*/
606		public void testConstructor14() {
607	<	try{
608	<	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
609	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
607	>	try {
608	>	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
609	>	shouldThrow();
610		}
611		catch (IllegalArgumentException success){}
612		}
613
614	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
614	>	/**
615	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
616	>	*/
617		public void testConstructor15() {
618	<	try{
619	<	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
620	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
618	>	try {
619	>	new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
620	>	shouldThrow();
621		}
622		catch (IllegalArgumentException success){}
623		}
624
625	<	/** Throws if workQueue is set to null */
626	<	public void testNullPointerException4() {
627	<	try{
628	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyREHandler());
629	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
625	>	/**
626	>	* Constructor throws if workQueue is set to null
627	>	*/
628	>	public void testConstructorNullPointerException4() {
629	>	try {
630	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler());
631	>	shouldThrow();
632		}
633		catch (NullPointerException success){}
634		}
635
636	<	/** Throws if handler is set to null */
637	<	public void testNullPointerException5() {
638	<	try{
636	>	/**
637	>	* Constructor throws if handler is set to null
638	>	*/
639	>	public void testConstructorNullPointerException5() {
640	>	try {
641		RejectedExecutionHandler r = null;
642	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
643	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
642	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
643	>	shouldThrow();
644		}
645		catch (NullPointerException success){}
646		}
647
648
649	<	/** Throws if corePoolSize argument is less than zero */
649	>	/**
650	>	* Constructor throws if corePoolSize argument is less than zero
651	>	*/
652		public void testConstructor16() {
653	<	try{
654	<	new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
655	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
653	>	try {
654	>	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
655	>	shouldThrow();
656		}
657		catch (IllegalArgumentException success){}
658		}
659
660	<	/** Throws if maximumPoolSize is less than zero */
660	>	/**
661	>	* Constructor throws if maximumPoolSize is less than zero
662	>	*/
663		public void testConstructor17() {
664	<	try{
665	<	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
666	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
664	>	try {
665	>	new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
666	>	shouldThrow();
667		}
668		catch (IllegalArgumentException success){}
669		}
670
671	<	/** Throws if maximumPoolSize is equal to zero */
671	>	/**
672	>	* Constructor throws if maximumPoolSize is equal to zero
673	>	*/
674		public void testConstructor18() {
675	<	try{
676	<	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
677	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
675	>	try {
676	>	new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
677	>	shouldThrow();
678		}
679		catch (IllegalArgumentException success){}
680		}
681
682	<	/** Throws if keepAliveTime is less than zero */
682	>	/**
683	>	* Constructor throws if keepAliveTime is less than zero
684	>	*/
685		public void testConstructor19() {
686	<	try{
687	<	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
688	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
686	>	try {
687	>	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
688	>	shouldThrow();
689		}
690		catch (IllegalArgumentException success){}
691		}
692
693	<	/** Throws if corePoolSize is greater than the maximumPoolSize */
693	>	/**
694	>	* Constructor throws if corePoolSize is greater than the maximumPoolSize
695	>	*/
696		public void testConstructor20() {
697	<	try{
698	<	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
699	<	fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
697	>	try {
698	>	new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
699	>	shouldThrow();
700		}
701		catch (IllegalArgumentException success){}
702		}
703
704	<	/** Throws if workQueue is set to null */
705	<	public void testNullPointerException6() {
706	<	try{
707	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory(),new MyREHandler());
708	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
704	>	/**
705	>	* Constructor throws if workQueue is set to null
706	>	*/
707	>	public void testConstructorNullPointerException6() {
708	>	try {
709	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
710	>	shouldThrow();
711		}
712		catch (NullPointerException success){}
713		}
714
715	<	/** Throws if handler is set to null */
716	<	public void testNullPointerException7() {
717	<	try{
715	>	/**
716	>	* Constructor throws if handler is set to null
717	>	*/
718	>	public void testConstructorNullPointerException7() {
719	>	try {
720		RejectedExecutionHandler r = null;
721	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),r);
722	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
721	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
722	>	shouldThrow();
723		}
724		catch (NullPointerException success){}
725		}
726
727	<	/** Throws if ThreadFactory is set top null */
728	<	public void testNullPointerException8() {
729	<	try{
727	>	/**
728	>	* Constructor throws if ThreadFactory is set top null
729	>	*/
730	>	public void testConstructorNullPointerException8() {
731	>	try {
732		ThreadFactory f = null;
733	<	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new MyREHandler());
734	<	fail("ThreadPoolExecutor constructor should throw a NullPointerException");
733	>	new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
734	>	shouldThrow();
735		}
736		catch (NullPointerException successdn8){}
737		}
738
739
740		/**
741	<	*   execute will throw RejectedExcutionException
742	<	*  ThreadPoolExecutor will throw one when more runnables are
499	<	*  executed then will fit in the Queue.
741	>	*  execute throws RejectedExecutionException
742	>	*  if saturated.
743		*/
744	<	public void testRejectedExecutionException(){
745	<	ThreadPoolExecutor tpe = null;
746	<	try{
747	<	tpe = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
748	<	} catch(Exception e){}
744	>	public void testSaturatedExecute() {
745	>	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
746	>	try {
747	>
748	>	for(int i = 0; i < 5; ++i){
749	>	p.execute(new MediumRunnable());
750	>	}
751	>	shouldThrow();
752	>	} catch(RejectedExecutionException success){}
753	>	joinPool(p);
754	>	}
755	>
756	>	/**
757	>	*  executor using CallerRunsPolicy runs task if saturated.
758	>	*/
759	>	public void testSaturatedExecute2() {
760	>	RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
761	>	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
762	>	try {
763	>
764	>	TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
765	>	for(int i = 0; i < 5; ++i){
766	>	tasks[i] = new TrackedNoOpRunnable();
767	>	}
768	>	TrackedLongRunnable mr = new TrackedLongRunnable();
769	>	p.execute(mr);
770	>	for(int i = 0; i < 5; ++i){
771	>	p.execute(tasks[i]);
772	>	}
773	>	for(int i = 1; i < 5; ++i) {
774	>	assertTrue(tasks[i].done);
775	>	}
776	>	p.shutdownNow();
777	>	} catch(RejectedExecutionException ex){
778	>	unexpectedException();
779	>	} finally {
780	>	joinPool(p);
781	>	}
782	>	}
783	>
784	>	/**
785	>	*  executor using DiscardPolicy drops task if saturated.
786	>	*/
787	>	public void testSaturatedExecute3() {
788	>	RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
789	>	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
790	>	try {
791	>
792	>	TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
793	>	for(int i = 0; i < 5; ++i){
794	>	tasks[i] = new TrackedNoOpRunnable();
795	>	}
796	>	p.execute(new TrackedLongRunnable());
797	>	for(int i = 0; i < 5; ++i){
798	>	p.execute(tasks[i]);
799	>	}
800	>	for(int i = 0; i < 5; ++i){
801	>	assertFalse(tasks[i].done);
802	>	}
803	>	p.shutdownNow();
804	>	} catch(RejectedExecutionException ex){
805	>	unexpectedException();
806	>	} finally {
807	>	joinPool(p);
808	>	}
809	>	}
810	>
811	>	/**
812	>	*  executor using DiscardOldestPolicy drops oldest task if saturated.
813	>	*/
814	>	public void testSaturatedExecute4() {
815	>	RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
816	>	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
817	>	try {
818	>	p.execute(new TrackedLongRunnable());
819	>	TrackedLongRunnable r2 = new TrackedLongRunnable();
820	>	p.execute(r2);
821	>	assertTrue(p.getQueue().contains(r2));
822	>	TrackedNoOpRunnable r3 = new TrackedNoOpRunnable();
823	>	p.execute(r3);
824	>	assertFalse(p.getQueue().contains(r2));
825	>	assertTrue(p.getQueue().contains(r3));
826	>	p.shutdownNow();
827	>	} catch(RejectedExecutionException ex){
828	>	unexpectedException();
829	>	} finally {
830	>	joinPool(p);
831	>	}
832	>	}
833	>
834	>	/**
835	>	*  execute throws RejectedExecutionException if shutdown
836	>	*/
837	>	public void testRejectedExecutionExceptionOnShutdown() {
838	>	ThreadPoolExecutor tpe =
839	>	new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
840		tpe.shutdown();
841	<	try{
841	>	try {
842		tpe.execute(new NoOpRunnable());
843	<	fail("ThreadPoolExecutor - void execute(Runnable) should throw RejectedExecutionException");
843	>	shouldThrow();
844		} catch(RejectedExecutionException success){}
845
846		joinPool(tpe);
847		}
848	+
849	+	/**
850	+	*  execute using CallerRunsPolicy drops task on shutdown
851	+	*/
852	+	public void testCallerRunsOnShutdown() {
853	+	RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy();
854	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
855	+
856	+	p.shutdown();
857	+	try {
858	+	TrackedNoOpRunnable r = new TrackedNoOpRunnable();
859	+	p.execute(r);
860	+	assertFalse(r.done);
861	+	} catch(RejectedExecutionException success){
862	+	unexpectedException();
863	+	} finally {
864	+	joinPool(p);
865	+	}
866	+	}
867	+
868	+	/**
869	+	*  execute using DiscardPolicy drops task on shutdown
870	+	*/
871	+	public void testDiscardOnShutdown() {
872	+	RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy();
873	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
874	+
875	+	p.shutdown();
876	+	try {
877	+	TrackedNoOpRunnable r = new TrackedNoOpRunnable();
878	+	p.execute(r);
879	+	assertFalse(r.done);
880	+	} catch(RejectedExecutionException success){
881	+	unexpectedException();
882	+	} finally {
883	+	joinPool(p);
884	+	}
885	+	}
886	+
887	+
888	+	/**
889	+	*  execute using DiscardOldestPolicy drops task on shutdown
890	+	*/
891	+	public void testDiscardOldestOnShutdown() {
892	+	RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy();
893	+	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
894	+
895	+	p.shutdown();
896	+	try {
897	+	TrackedNoOpRunnable r = new TrackedNoOpRunnable();
898	+	p.execute(r);
899	+	assertFalse(r.done);
900	+	} catch(RejectedExecutionException success){
901	+	unexpectedException();
902	+	} finally {
903	+	joinPool(p);
904	+	}
905	+	}
906	+
907	+
908	+	/**
909	+	*  execute (null) throws NPE
910	+	*/
911	+	public void testExecuteNull() {
912	+	ThreadPoolExecutor tpe = null;
913	+	try {
914	+	tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
915	+	tpe.execute(null);
916	+	shouldThrow();
917	+	} catch(NullPointerException success){}
918	+
919	+	joinPool(tpe);
920	+	}
921
922		/**
923	<	*   setCorePoolSize will throw IllegalArgumentException
517	<	*  when given a negative
923	>	*  setCorePoolSize of negative value throws IllegalArgumentException
924		*/
925	<	public void testCorePoolSizeIllegalArgumentException(){
925	>	public void testCorePoolSizeIllegalArgumentException() {
926		ThreadPoolExecutor tpe = null;
927	<	try{
928	<	tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
927	>	try {
928	>	tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
929		} catch(Exception e){}
930	<	try{
930	>	try {
931		tpe.setCorePoolSize(-1);
932	<	fail("ThreadPoolExecutor - void setCorePoolSize(int) should throw IllegalArgumentException");
932	>	shouldThrow();
933		} catch(IllegalArgumentException success){
934		} finally {
935		tpe.shutdown();
#	Line 531 | Line 937 | public class ThreadPoolExecutorTest exte
937		joinPool(tpe);
938		}
939
534	–
940		/**
941	<	*   setMaximumPoolSize(int) will throw IllegalArgumentException
942	<	*  if given a value less the it's actual core pool size
941	>	*  setMaximumPoolSize(int) throws IllegalArgumentException if
942	>	*  given a value less the core pool size
943		*/
944	<	public void testMaximumPoolSizeIllegalArgumentException(){
944	>	public void testMaximumPoolSizeIllegalArgumentException() {
945		ThreadPoolExecutor tpe = null;
946	<	try{
947	<	tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
946	>	try {
947	>	tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
948		} catch(Exception e){}
949	<	try{
949	>	try {
950		tpe.setMaximumPoolSize(1);
951	<	fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
951	>	shouldThrow();
952		} catch(IllegalArgumentException success){
953		} finally {
954		tpe.shutdown();
#	Line 552 | Line 957 | public class ThreadPoolExecutorTest exte
957		}
958
959		/**
960	<	*   setMaximumPoolSize will throw IllegalArgumentException
961	<	*  if given a negative number
960	>	*  setMaximumPoolSize throws IllegalArgumentException
961	>	*  if given a negative value
962		*/
963	<	public void testMaximumPoolSizeIllegalArgumentException2(){
963	>	public void testMaximumPoolSizeIllegalArgumentException2() {
964		ThreadPoolExecutor tpe = null;
965	<	try{
966	<	tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
965	>	try {
966	>	tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
967		} catch(Exception e){}
968	<	try{
968	>	try {
969		tpe.setMaximumPoolSize(-1);
970	<	fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
970	>	shouldThrow();
971		} catch(IllegalArgumentException success){
972		} finally {
973		tpe.shutdown();
#	Line 572 | Line 977 | public class ThreadPoolExecutorTest exte
977
978
979		/**
980	<	*   setKeepAliveTime will throw IllegalArgumentException
980	>	*  setKeepAliveTime  throws IllegalArgumentException
981		*  when given a negative value
982		*/
983	<	public void testKeepAliveTimeIllegalArgumentException(){
983	>	public void testKeepAliveTimeIllegalArgumentException() {
984		ThreadPoolExecutor tpe = null;
985	<	try{
986	<	tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
985	>	try {
986	>	tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
987		} catch(Exception e){}
988
989	<	try{
989	>	try {
990		tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
991	<	fail("ThreadPoolExecutor - void setKeepAliveTime(long, TimeUnit) should throw IllegalArgumentException");
991	>	shouldThrow();
992		} catch(IllegalArgumentException success){
993		} finally {
994		tpe.shutdown();
995		}
996		joinPool(tpe);
997		}
998	<
998	>
999	>	/**
1000	>	* terminated() is called on termination
1001	>	*/
1002	>	public void testTerminated() {
1003	>	ExtendedTPE tpe = new ExtendedTPE();
1004	>	tpe.shutdown();
1005	>	assertTrue(tpe.terminatedCalled);
1006	>	joinPool(tpe);
1007	>	}
1008	>
1009	>	/**
1010	>	* beforeExecute and afterExecute are called when executing task
1011	>	*/
1012	>	public void testBeforeAfter() {
1013	>	ExtendedTPE tpe = new ExtendedTPE();
1014	>	try {
1015	>	TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1016	>	tpe.execute(r);
1017	>	Thread.sleep(SHORT_DELAY_MS);
1018	>	assertTrue(r.done);
1019	>	assertTrue(tpe.beforeCalled);
1020	>	assertTrue(tpe.afterCalled);
1021	>	tpe.shutdown();
1022	>	}
1023	>	catch(Exception ex) {
1024	>	unexpectedException();
1025	>	} finally {
1026	>	joinPool(tpe);
1027	>	}
1028	>	}
1029		}

Diff Legend

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