ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorSubclassTest.java (file contents):
Revision 1.1 by dl, Fri May 20 16:30:17 2005 UTC vs.
Revision 1.17 by jsr166, Tue Dec 1 22:51:44 2009 UTC

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

Diff Legend

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