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.18 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.41 by jsr166, Mon Sep 28 02:41:29 2015 UTC

#	Line 1 | Line 1
1		/*
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
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
8
9	–	import java.util.concurrent.*;
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	<	import java.util.concurrent.locks.*;
10	>	import static java.util.concurrent.TimeUnit.SECONDS;
11
12	<	import junit.framework.*;
13	<	import java.util.*;
12	>	import java.util.ArrayList;
13	>	import java.util.List;
14	>	import java.util.concurrent.ArrayBlockingQueue;
15	>	import java.util.concurrent.BlockingQueue;
16	>	import java.util.concurrent.Callable;
17	>	import java.util.concurrent.CancellationException;
18	>	import java.util.concurrent.CountDownLatch;
19	>	import java.util.concurrent.ExecutionException;
20	>	import java.util.concurrent.Executors;
21	>	import java.util.concurrent.ExecutorService;
22	>	import java.util.concurrent.Future;
23	>	import java.util.concurrent.FutureTask;
24	>	import java.util.concurrent.LinkedBlockingQueue;
25	>	import java.util.concurrent.RejectedExecutionException;
26	>	import java.util.concurrent.RejectedExecutionHandler;
27	>	import java.util.concurrent.RunnableFuture;
28	>	import java.util.concurrent.SynchronousQueue;
29	>	import java.util.concurrent.ThreadFactory;
30	>	import java.util.concurrent.ThreadPoolExecutor;
31	>	import java.util.concurrent.TimeoutException;
32	>	import java.util.concurrent.TimeUnit;
33	>	import java.util.concurrent.atomic.AtomicInteger;
34	>	import java.util.concurrent.locks.Condition;
35	>	import java.util.concurrent.locks.ReentrantLock;
36	>
37	>	import junit.framework.Test;
38	>	import junit.framework.TestSuite;
39
40		public class ThreadPoolExecutorSubclassTest extends JSR166TestCase {
41		public static void main(String[] args) {
42	<	junit.textui.TestRunner.run(suite());
42	>	main(suite(), args);
43		}
44		public static Test suite() {
45		return new TestSuite(ThreadPoolExecutorSubclassTest.class);
#	Line 37 | Line 61 | public class ThreadPoolExecutorSubclassT
61		CustomTask(final Runnable r, final V res) {
62		if (r == null) throw new NullPointerException();
63		callable = new Callable<V>() {
64	<	public V call() throws Exception { r.run(); return res; }};
64	>	public V call() throws Exception { r.run(); return res; }};
65		}
66		public boolean isDone() {
67		lock.lock(); try { return done; } finally { lock.unlock() ; }
#	Line 60 | Line 84 | public class ThreadPoolExecutorSubclassT
84		finally { lock.unlock() ; }
85		}
86		public void run() {
63	–	boolean runme;
87		lock.lock();
88		try {
89	<	runme = !done;
90	<	if (!runme)
91	<	thread = Thread.currentThread();
89	>	if (done)
90	>	return;
91	>	thread = Thread.currentThread();
92		}
93		finally { lock.unlock() ; }
71	–	if (!runme) return;
94		V v = null;
95		Exception e = null;
96		try {
#	Line 117 | Line 139 | public class ThreadPoolExecutorSubclassT
139		}
140		}
141
120	–
142		static class CustomTPE extends ThreadPoolExecutor {
143		protected <V> RunnableFuture<V> newTaskFor(Callable<V> c) {
144		return new CustomTask<V>(c);
#	Line 164 | Line 185 | public class ThreadPoolExecutorSubclassT
185		workQueue, threadFactory, handler);
186		}
187
188	<	volatile boolean beforeCalled = false;
189	<	volatile boolean afterCalled = false;
190	<	volatile boolean terminatedCalled = false;
188	>	final CountDownLatch beforeCalled = new CountDownLatch(1);
189	>	final CountDownLatch afterCalled = new CountDownLatch(1);
190	>	final CountDownLatch terminatedCalled = new CountDownLatch(1);
191	>
192		public CustomTPE() {
193		super(1, 1, LONG_DELAY_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
194		}
195		protected void beforeExecute(Thread t, Runnable r) {
196	<	beforeCalled = true;
196	>	beforeCalled.countDown();
197		}
198		protected void afterExecute(Runnable r, Throwable t) {
199	<	afterCalled = true;
199	>	afterCalled.countDown();
200		}
201		protected void terminated() {
202	<	terminatedCalled = true;
202	>	terminatedCalled.countDown();
203		}
204
205	+	public boolean beforeCalled() {
206	+	return beforeCalled.getCount() == 0;
207	+	}
208	+	public boolean afterCalled() {
209	+	return afterCalled.getCount() == 0;
210	+	}
211	+	public boolean terminatedCalled() {
212	+	return terminatedCalled.getCount() == 0;
213	+	}
214		}
215
216		static class FailingThreadFactory implements ThreadFactory {
#	Line 190 | Line 221 | public class ThreadPoolExecutorSubclassT
221		}
222		}
223
193	–
224		/**
225	<	*  execute successfully executes a runnable
225	>	* execute successfully executes a runnable
226		*/
227		public void testExecute() throws InterruptedException {
228	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
228	>	final ThreadPoolExecutor p =
229	>	new CustomTPE(1, 1,
230	>	LONG_DELAY_MS, MILLISECONDS,
231	>	new ArrayBlockingQueue<Runnable>(10));
232	>	final CountDownLatch done = new CountDownLatch(1);
233	>	final Runnable task = new CheckedRunnable() {
234	>	public void realRun() {
235	>	done.countDown();
236	>	}};
237		try {
238	<	p1.execute(new ShortRunnable());
239	<	Thread.sleep(SMALL_DELAY_MS);
238	>	p.execute(task);
239	>	assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
240		} finally {
241	<	joinPool(p1);
241	>	joinPool(p);
242		}
243		}
244
245		/**
246	<	*  getActiveCount increases but doesn't overestimate, when a
247	<	*  thread becomes active
246	>	* getActiveCount increases but doesn't overestimate, when a
247	>	* thread becomes active
248		*/
249		public void testGetActiveCount() throws InterruptedException {
250	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
251	<	assertEquals(0, p2.getActiveCount());
252	<	p2.execute(new MediumRunnable());
253	<	Thread.sleep(SHORT_DELAY_MS);
254	<	assertEquals(1, p2.getActiveCount());
255	<	joinPool(p2);
250	>	final ThreadPoolExecutor p =
251	>	new CustomTPE(2, 2,
252	>	LONG_DELAY_MS, MILLISECONDS,
253	>	new ArrayBlockingQueue<Runnable>(10));
254	>	final CountDownLatch threadStarted = new CountDownLatch(1);
255	>	final CountDownLatch done = new CountDownLatch(1);
256	>	try {
257	>	assertEquals(0, p.getActiveCount());
258	>	p.execute(new CheckedRunnable() {
259	>	public void realRun() throws InterruptedException {
260	>	threadStarted.countDown();
261	>	assertEquals(1, p.getActiveCount());
262	>	done.await();
263	>	}});
264	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
265	>	assertEquals(1, p.getActiveCount());
266	>	} finally {
267	>	done.countDown();
268	>	joinPool(p);
269	>	}
270		}
271
272		/**
273	<	*  prestartCoreThread starts a thread if under corePoolSize, else doesn't
273	>	* prestartCoreThread starts a thread if under corePoolSize, else doesn't
274		*/
275		public void testPrestartCoreThread() {
276	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
277	<	assertEquals(0, p2.getPoolSize());
278	<	assertTrue(p2.prestartCoreThread());
279	<	assertEquals(1, p2.getPoolSize());
280	<	assertTrue(p2.prestartCoreThread());
281	<	assertEquals(2, p2.getPoolSize());
282	<	assertFalse(p2.prestartCoreThread());
283	<	assertEquals(2, p2.getPoolSize());
284	<	joinPool(p2);
276	>	ThreadPoolExecutor p = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
277	>	assertEquals(0, p.getPoolSize());
278	>	assertTrue(p.prestartCoreThread());
279	>	assertEquals(1, p.getPoolSize());
280	>	assertTrue(p.prestartCoreThread());
281	>	assertEquals(2, p.getPoolSize());
282	>	assertFalse(p.prestartCoreThread());
283	>	assertEquals(2, p.getPoolSize());
284	>	joinPool(p);
285		}
286
287		/**
288	<	*  prestartAllCoreThreads starts all corePoolSize threads
288	>	* prestartAllCoreThreads starts all corePoolSize threads
289		*/
290		public void testPrestartAllCoreThreads() {
291	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
292	<	assertEquals(0, p2.getPoolSize());
293	<	p2.prestartAllCoreThreads();
294	<	assertEquals(2, p2.getPoolSize());
295	<	p2.prestartAllCoreThreads();
296	<	assertEquals(2, p2.getPoolSize());
297	<	joinPool(p2);
291	>	ThreadPoolExecutor p = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
292	>	assertEquals(0, p.getPoolSize());
293	>	p.prestartAllCoreThreads();
294	>	assertEquals(2, p.getPoolSize());
295	>	p.prestartAllCoreThreads();
296	>	assertEquals(2, p.getPoolSize());
297	>	joinPool(p);
298		}
299
300		/**
301	<	*   getCompletedTaskCount increases, but doesn't overestimate,
302	<	*   when tasks complete
301	>	* getCompletedTaskCount increases, but doesn't overestimate,
302	>	* when tasks complete
303		*/
304		public void testGetCompletedTaskCount() throws InterruptedException {
305	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
306	<	assertEquals(0, p2.getCompletedTaskCount());
307	<	p2.execute(new ShortRunnable());
308	<	Thread.sleep(SMALL_DELAY_MS);
309	<	assertEquals(1, p2.getCompletedTaskCount());
310	<	try { p2.shutdown(); } catch (SecurityException ok) { return; }
311	<	joinPool(p2);
305	>	final ThreadPoolExecutor p =
306	>	new CustomTPE(2, 2,
307	>	LONG_DELAY_MS, MILLISECONDS,
308	>	new ArrayBlockingQueue<Runnable>(10));
309	>	final CountDownLatch threadStarted = new CountDownLatch(1);
310	>	final CountDownLatch threadProceed = new CountDownLatch(1);
311	>	final CountDownLatch threadDone = new CountDownLatch(1);
312	>	try {
313	>	assertEquals(0, p.getCompletedTaskCount());
314	>	p.execute(new CheckedRunnable() {
315	>	public void realRun() throws InterruptedException {
316	>	threadStarted.countDown();
317	>	assertEquals(0, p.getCompletedTaskCount());
318	>	threadProceed.await();
319	>	threadDone.countDown();
320	>	}});
321	>	await(threadStarted);
322	>	assertEquals(0, p.getCompletedTaskCount());
323	>	threadProceed.countDown();
324	>	threadDone.await();
325	>	long startTime = System.nanoTime();
326	>	while (p.getCompletedTaskCount() != 1) {
327	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
328	>	fail("timed out");
329	>	Thread.yield();
330	>	}
331	>	} finally {
332	>	joinPool(p);
333	>	}
334		}
335
336		/**
337	<	*   getCorePoolSize returns size given in constructor if not otherwise set
337	>	* getCorePoolSize returns size given in constructor if not otherwise set
338		*/
339		public void testGetCorePoolSize() {
340	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
341	<	assertEquals(1, p1.getCorePoolSize());
342	<	joinPool(p1);
340	>	ThreadPoolExecutor p = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
341	>	assertEquals(1, p.getCorePoolSize());
342	>	joinPool(p);
343		}
344
345		/**
346	<	*   getKeepAliveTime returns value given in constructor if not otherwise set
346	>	* getKeepAliveTime returns value given in constructor if not otherwise set
347		*/
348		public void testGetKeepAliveTime() {
349	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
350	<	assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS));
351	<	joinPool(p2);
349	>	ThreadPoolExecutor p = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
350	>	assertEquals(1, p.getKeepAliveTime(SECONDS));
351	>	joinPool(p);
352		}
353
280	–
354		/**
355		* getThreadFactory returns factory in constructor if not set
356		*/
#	Line 299 | Line 372 | public class ThreadPoolExecutorSubclassT
372		joinPool(p);
373		}
374
302	–
375		/**
376		* setThreadFactory(null) throws NPE
377		*/
#	Line 336 | Line 408 | public class ThreadPoolExecutorSubclassT
408		joinPool(p);
409		}
410
339	–
411		/**
412		* setRejectedExecutionHandler(null) throws NPE
413		*/
#	Line 351 | Line 422 | public class ThreadPoolExecutorSubclassT
422		}
423		}
424
354	–
425		/**
426	<	*   getLargestPoolSize increases, but doesn't overestimate, when
427	<	*   multiple threads active
426	>	* getLargestPoolSize increases, but doesn't overestimate, when
427	>	* multiple threads active
428		*/
429		public void testGetLargestPoolSize() throws InterruptedException {
430	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
431	<	assertEquals(0, p2.getLargestPoolSize());
432	<	p2.execute(new MediumRunnable());
433	<	p2.execute(new MediumRunnable());
434	<	Thread.sleep(SHORT_DELAY_MS);
435	<	assertEquals(2, p2.getLargestPoolSize());
436	<	joinPool(p2);
430	>	final int THREADS = 3;
431	>	final ThreadPoolExecutor p =
432	>	new CustomTPE(THREADS, THREADS,
433	>	LONG_DELAY_MS, MILLISECONDS,
434	>	new ArrayBlockingQueue<Runnable>(10));
435	>	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
436	>	final CountDownLatch done = new CountDownLatch(1);
437	>	try {
438	>	assertEquals(0, p.getLargestPoolSize());
439	>	for (int i = 0; i < THREADS; i++)
440	>	p.execute(new CheckedRunnable() {
441	>	public void realRun() throws InterruptedException {
442	>	threadsStarted.countDown();
443	>	done.await();
444	>	assertEquals(THREADS, p.getLargestPoolSize());
445	>	}});
446	>	assertTrue(threadsStarted.await(SMALL_DELAY_MS, MILLISECONDS));
447	>	assertEquals(THREADS, p.getLargestPoolSize());
448	>	} finally {
449	>	done.countDown();
450	>	joinPool(p);
451	>	assertEquals(THREADS, p.getLargestPoolSize());
452	>	}
453		}
454
455		/**
456	<	*   getMaximumPoolSize returns value given in constructor if not
457	<	*   otherwise set
456	>	* getMaximumPoolSize returns value given in constructor if not
457	>	* otherwise set
458		*/
459		public void testGetMaximumPoolSize() {
460	<	ThreadPoolExecutor p2 = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
461	<	assertEquals(2, p2.getMaximumPoolSize());
462	<	joinPool(p2);
460	>	ThreadPoolExecutor p = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
461	>	assertEquals(2, p.getMaximumPoolSize());
462	>	joinPool(p);
463		}
464
465		/**
466	<	*   getPoolSize increases, but doesn't overestimate, when threads
467	<	*   become active
466	>	* getPoolSize increases, but doesn't overestimate, when threads
467	>	* become active
468		*/
469	<	public void testGetPoolSize() {
470	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
471	<	assertEquals(0, p1.getPoolSize());
472	<	p1.execute(new MediumRunnable());
473	<	assertEquals(1, p1.getPoolSize());
474	<	joinPool(p1);
469	>	public void testGetPoolSize() throws InterruptedException {
470	>	final ThreadPoolExecutor p =
471	>	new CustomTPE(1, 1,
472	>	LONG_DELAY_MS, MILLISECONDS,
473	>	new ArrayBlockingQueue<Runnable>(10));
474	>	final CountDownLatch threadStarted = new CountDownLatch(1);
475	>	final CountDownLatch done = new CountDownLatch(1);
476	>	try {
477	>	assertEquals(0, p.getPoolSize());
478	>	p.execute(new CheckedRunnable() {
479	>	public void realRun() throws InterruptedException {
480	>	threadStarted.countDown();
481	>	assertEquals(1, p.getPoolSize());
482	>	done.await();
483	>	}});
484	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
485	>	assertEquals(1, p.getPoolSize());
486	>	} finally {
487	>	done.countDown();
488	>	joinPool(p);
489	>	}
490		}
491
492		/**
493	<	*  getTaskCount increases, but doesn't overestimate, when tasks submitted
493	>	* getTaskCount increases, but doesn't overestimate, when tasks submitted
494		*/
495		public void testGetTaskCount() throws InterruptedException {
496	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
497	<	assertEquals(0, p1.getTaskCount());
498	<	p1.execute(new MediumRunnable());
499	<	Thread.sleep(SHORT_DELAY_MS);
500	<	assertEquals(1, p1.getTaskCount());
501	<	joinPool(p1);
496	>	final ThreadPoolExecutor p =
497	>	new CustomTPE(1, 1,
498	>	LONG_DELAY_MS, MILLISECONDS,
499	>	new ArrayBlockingQueue<Runnable>(10));
500	>	final CountDownLatch threadStarted = new CountDownLatch(1);
501	>	final CountDownLatch done = new CountDownLatch(1);
502	>	try {
503	>	assertEquals(0, p.getTaskCount());
504	>	p.execute(new CheckedRunnable() {
505	>	public void realRun() throws InterruptedException {
506	>	threadStarted.countDown();
507	>	assertEquals(1, p.getTaskCount());
508	>	done.await();
509	>	}});
510	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
511	>	assertEquals(1, p.getTaskCount());
512	>	} finally {
513	>	done.countDown();
514	>	joinPool(p);
515	>	}
516		}
517
518		/**
519	<	*   isShutDown is false before shutdown, true after
519	>	* isShutdown is false before shutdown, true after
520		*/
521		public void testIsShutdown() {
522
523	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
524	<	assertFalse(p1.isShutdown());
525	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
526	<	assertTrue(p1.isShutdown());
527	<	joinPool(p1);
523	>	ThreadPoolExecutor p = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
524	>	assertFalse(p.isShutdown());
525	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
526	>	assertTrue(p.isShutdown());
527	>	joinPool(p);
528		}
529
415	–
530		/**
531	<	*  isTerminated is false before termination, true after
531	>	* isTerminated is false before termination, true after
532		*/
533		public void testIsTerminated() throws InterruptedException {
534	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
535	<	assertFalse(p1.isTerminated());
536	<	try {
537	<	p1.execute(new MediumRunnable());
538	<	} finally {
539	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
540	<	}
541	<	assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
542	<	assertTrue(p1.isTerminated());
534	>	final ThreadPoolExecutor p =
535	>	new CustomTPE(1, 1,
536	>	LONG_DELAY_MS, MILLISECONDS,
537	>	new ArrayBlockingQueue<Runnable>(10));
538	>	final CountDownLatch threadStarted = new CountDownLatch(1);
539	>	final CountDownLatch done = new CountDownLatch(1);
540	>	try {
541	>	assertFalse(p.isTerminating());
542	>	p.execute(new CheckedRunnable() {
543	>	public void realRun() throws InterruptedException {
544	>	assertFalse(p.isTerminating());
545	>	threadStarted.countDown();
546	>	done.await();
547	>	}});
548	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
549	>	assertFalse(p.isTerminating());
550	>	done.countDown();
551	>	} finally {
552	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
553	>	}
554	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
555	>	assertTrue(p.isTerminated());
556	>	assertFalse(p.isTerminating());
557		}
558
559		/**
560	<	*  isTerminating is not true when running or when terminated
560	>	* isTerminating is not true when running or when terminated
561		*/
562		public void testIsTerminating() throws InterruptedException {
563	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
564	<	assertFalse(p1.isTerminating());
565	<	try {
566	<	p1.execute(new SmallRunnable());
567	<	assertFalse(p1.isTerminating());
568	<	} finally {
569	<	try { p1.shutdown(); } catch (SecurityException ok) { return; }
570	<	}
571	<	assertTrue(p1.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
572	<	assertTrue(p1.isTerminated());
573	<	assertFalse(p1.isTerminating());
563	>	final ThreadPoolExecutor p =
564	>	new CustomTPE(1, 1,
565	>	LONG_DELAY_MS, MILLISECONDS,
566	>	new ArrayBlockingQueue<Runnable>(10));
567	>	final CountDownLatch threadStarted = new CountDownLatch(1);
568	>	final CountDownLatch done = new CountDownLatch(1);
569	>	try {
570	>	assertFalse(p.isTerminating());
571	>	p.execute(new CheckedRunnable() {
572	>	public void realRun() throws InterruptedException {
573	>	assertFalse(p.isTerminating());
574	>	threadStarted.countDown();
575	>	done.await();
576	>	}});
577	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
578	>	assertFalse(p.isTerminating());
579	>	done.countDown();
580	>	} finally {
581	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
582	>	}
583	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
584	>	assertTrue(p.isTerminated());
585	>	assertFalse(p.isTerminating());
586		}
587
588		/**
589		* getQueue returns the work queue, which contains queued tasks
590		*/
591		public void testGetQueue() throws InterruptedException {
592	<	BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
593	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, q);
594	<	FutureTask[] tasks = new FutureTask[5];
595	<	for (int i = 0; i < 5; i++) {
596	<	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
597	<	p1.execute(tasks[i]);
598	<	}
599	<	try {
600	<	Thread.sleep(SHORT_DELAY_MS);
601	<	BlockingQueue<Runnable> wq = p1.getQueue();
602	<	assertSame(q, wq);
603	<	assertFalse(wq.contains(tasks[0]));
604	<	assertTrue(wq.contains(tasks[4]));
605	<	for (int i = 1; i < 5; ++i)
606	<	tasks[i].cancel(true);
607	<	p1.shutdownNow();
592	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
593	>	final ThreadPoolExecutor p =
594	>	new CustomTPE(1, 1,
595	>	LONG_DELAY_MS, MILLISECONDS,
596	>	q);
597	>	final CountDownLatch threadStarted = new CountDownLatch(1);
598	>	final CountDownLatch done = new CountDownLatch(1);
599	>	try {
600	>	FutureTask[] tasks = new FutureTask[5];
601	>	for (int i = 0; i < tasks.length; i++) {
602	>	Callable task = new CheckedCallable<Boolean>() {
603	>	public Boolean realCall() throws InterruptedException {
604	>	threadStarted.countDown();
605	>	assertSame(q, p.getQueue());
606	>	done.await();
607	>	return Boolean.TRUE;
608	>	}};
609	>	tasks[i] = new FutureTask(task);
610	>	p.execute(tasks[i]);
611	>	}
612	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
613	>	assertSame(q, p.getQueue());
614	>	assertFalse(q.contains(tasks[0]));
615	>	assertTrue(q.contains(tasks[tasks.length - 1]));
616	>	assertEquals(tasks.length - 1, q.size());
617		} finally {
618	<	joinPool(p1);
618	>	done.countDown();
619	>	joinPool(p);
620		}
621		}
622
#	Line 475 | Line 625 | public class ThreadPoolExecutorSubclassT
625		*/
626		public void testRemove() throws InterruptedException {
627		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
628	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, q);
629	<	FutureTask[] tasks = new FutureTask[5];
630	<	for (int i = 0; i < 5; i++) {
631	<	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
632	<	p1.execute(tasks[i]);
633	<	}
634	<	try {
635	<	Thread.sleep(SHORT_DELAY_MS);
636	<	assertFalse(p1.remove(tasks[0]));
628	>	final ThreadPoolExecutor p =
629	>	new CustomTPE(1, 1,
630	>	LONG_DELAY_MS, MILLISECONDS,
631	>	q);
632	>	Runnable[] tasks = new Runnable[6];
633	>	final CountDownLatch threadStarted = new CountDownLatch(1);
634	>	final CountDownLatch done = new CountDownLatch(1);
635	>	try {
636	>	for (int i = 0; i < tasks.length; i++) {
637	>	tasks[i] = new CheckedRunnable() {
638	>	public void realRun() throws InterruptedException {
639	>	threadStarted.countDown();
640	>	done.await();
641	>	}};
642	>	p.execute(tasks[i]);
643	>	}
644	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
645	>	assertFalse(p.remove(tasks[0]));
646		assertTrue(q.contains(tasks[4]));
647		assertTrue(q.contains(tasks[3]));
648	<	assertTrue(p1.remove(tasks[4]));
649	<	assertFalse(p1.remove(tasks[4]));
648	>	assertTrue(p.remove(tasks[4]));
649	>	assertFalse(p.remove(tasks[4]));
650		assertFalse(q.contains(tasks[4]));
651		assertTrue(q.contains(tasks[3]));
652	<	assertTrue(p1.remove(tasks[3]));
652	>	assertTrue(p.remove(tasks[3]));
653		assertFalse(q.contains(tasks[3]));
654		} finally {
655	<	joinPool(p1);
655	>	done.countDown();
656	>	joinPool(p);
657		}
658		}
659
660		/**
661	<	*   purge removes cancelled tasks from the queue
661	>	* purge removes cancelled tasks from the queue
662		*/
663	<	public void testPurge() {
664	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
663	>	public void testPurge() throws InterruptedException {
664	>	final CountDownLatch threadStarted = new CountDownLatch(1);
665	>	final CountDownLatch done = new CountDownLatch(1);
666	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
667	>	final ThreadPoolExecutor p =
668	>	new CustomTPE(1, 1,
669	>	LONG_DELAY_MS, MILLISECONDS,
670	>	q);
671		FutureTask[] tasks = new FutureTask[5];
672	<	for (int i = 0; i < 5; i++) {
673	<	tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE);
674	<	p1.execute(tasks[i]);
672	>	try {
673	>	for (int i = 0; i < tasks.length; i++) {
674	>	Callable task = new CheckedCallable<Boolean>() {
675	>	public Boolean realCall() throws InterruptedException {
676	>	threadStarted.countDown();
677	>	done.await();
678	>	return Boolean.TRUE;
679	>	}};
680	>	tasks[i] = new FutureTask(task);
681	>	p.execute(tasks[i]);
682	>	}
683	>	assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
684	>	assertEquals(tasks.length, p.getTaskCount());
685	>	assertEquals(tasks.length - 1, q.size());
686	>	assertEquals(1L, p.getActiveCount());
687	>	assertEquals(0L, p.getCompletedTaskCount());
688	>	tasks[4].cancel(true);
689	>	tasks[3].cancel(false);
690	>	p.purge();
691	>	assertEquals(tasks.length - 3, q.size());
692	>	assertEquals(tasks.length - 2, p.getTaskCount());
693	>	p.purge();         // Nothing to do
694	>	assertEquals(tasks.length - 3, q.size());
695	>	assertEquals(tasks.length - 2, p.getTaskCount());
696	>	} finally {
697	>	done.countDown();
698	>	joinPool(p);
699		}
510	–	tasks[4].cancel(true);
511	–	tasks[3].cancel(true);
512	–	p1.purge();
513	–	long count = p1.getTaskCount();
514	–	assertTrue(count >= 2 && count < 5);
515	–	joinPool(p1);
700		}
701
702		/**
703	<	*  shutDownNow returns a list containing tasks that were not run
703	>	* shutdownNow returns a list containing tasks that were not run,
704	>	* and those tasks are drained from the queue
705		*/
706	<	public void testShutDownNow() {
707	<	ThreadPoolExecutor p1 = new CustomTPE(1, 1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
708	<	List l;
709	<	try {
710	<	for (int i = 0; i < 5; i++)
711	<	p1.execute(new MediumPossiblyInterruptedRunnable());
712	<	}
713	<	finally {
706	>	public void testShutdownNow() throws InterruptedException {
707	>	final int poolSize = 2;
708	>	final int count = 5;
709	>	final AtomicInteger ran = new AtomicInteger(0);
710	>	ThreadPoolExecutor p =
711	>	new CustomTPE(poolSize, poolSize, LONG_DELAY_MS, MILLISECONDS,
712	>	new ArrayBlockingQueue<Runnable>(10));
713	>	CountDownLatch threadsStarted = new CountDownLatch(poolSize);
714	>	CheckedRunnable waiter = new CheckedRunnable() { public void realRun() {
715	>	threadsStarted.countDown();
716		try {
717	<	l = p1.shutdownNow();
718	<	} catch (SecurityException ok) { return; }
719	<	}
720	<	assertTrue(p1.isShutdown());
721	<	assertTrue(l.size() <= 4);
717	>	MILLISECONDS.sleep(2 * LONG_DELAY_MS);
718	>	} catch (InterruptedException success) {}
719	>	ran.getAndIncrement();
720	>	}};
721	>	for (int i = 0; i < count; i++)
722	>	p.execute(waiter);
723	>	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
724	>	final List<Runnable> queuedTasks;
725	>	try {
726	>	queuedTasks = p.shutdownNow();
727	>	} catch (SecurityException ok) {
728	>	return; // Allowed in case test doesn't have privs
729	>	}
730	>	assertTrue(p.isShutdown());
731	>	assertTrue(p.getQueue().isEmpty());
732	>	assertEquals(count - poolSize, queuedTasks.size());
733	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
734	>	assertTrue(p.isTerminated());
735	>	assertEquals(poolSize, ran.get());
736		}
737
738		// Exception Tests
739
539	–
740		/**
741		* Constructor throws if corePoolSize argument is less than zero
742		*/
743		public void testConstructor1() {
744		try {
745	<	new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
745	>	new CustomTPE(-1, 1, 1L, SECONDS,
746	>	new ArrayBlockingQueue<Runnable>(10));
747		shouldThrow();
748		} catch (IllegalArgumentException success) {}
749		}
#	Line 552 | Line 753 | public class ThreadPoolExecutorSubclassT
753		*/
754		public void testConstructor2() {
755		try {
756	<	new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
756	>	new CustomTPE(1, -1, 1L, SECONDS,
757	>	new ArrayBlockingQueue<Runnable>(10));
758		shouldThrow();
759		} catch (IllegalArgumentException success) {}
760		}
#	Line 562 | Line 764 | public class ThreadPoolExecutorSubclassT
764		*/
765		public void testConstructor3() {
766		try {
767	<	new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
767	>	new CustomTPE(1, 0, 1L, SECONDS,
768	>	new ArrayBlockingQueue<Runnable>(10));
769		shouldThrow();
770		} catch (IllegalArgumentException success) {}
771		}
#	Line 572 | Line 775 | public class ThreadPoolExecutorSubclassT
775		*/
776		public void testConstructor4() {
777		try {
778	<	new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
778	>	new CustomTPE(1, 2, -1L, SECONDS,
779	>	new ArrayBlockingQueue<Runnable>(10));
780		shouldThrow();
781		} catch (IllegalArgumentException success) {}
782		}
#	Line 582 | Line 786 | public class ThreadPoolExecutorSubclassT
786		*/
787		public void testConstructor5() {
788		try {
789	<	new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
789	>	new CustomTPE(2, 1, 1L, SECONDS,
790	>	new ArrayBlockingQueue<Runnable>(10));
791		shouldThrow();
792		} catch (IllegalArgumentException success) {}
793		}
#	Line 592 | Line 797 | public class ThreadPoolExecutorSubclassT
797		*/
798		public void testConstructorNullPointerException() {
799		try {
800	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null);
800	>	new CustomTPE(1, 2, 1L, SECONDS, null);
801		shouldThrow();
802		} catch (NullPointerException success) {}
803		}
804
600	–
601	–
805		/**
806		* Constructor throws if corePoolSize argument is less than zero
807		*/
808		public void testConstructor6() {
809		try {
810	<	new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
810	>	new CustomTPE(-1, 1, 1L, SECONDS,
811	>	new ArrayBlockingQueue<Runnable>(10),
812	>	new SimpleThreadFactory());
813		shouldThrow();
814		} catch (IllegalArgumentException success) {}
815		}
#	Line 614 | Line 819 | public class ThreadPoolExecutorSubclassT
819		*/
820		public void testConstructor7() {
821		try {
822	<	new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
822	>	new CustomTPE(1,-1, 1L, SECONDS,
823	>	new ArrayBlockingQueue<Runnable>(10),
824	>	new SimpleThreadFactory());
825		shouldThrow();
826		} catch (IllegalArgumentException success) {}
827		}
#	Line 624 | Line 831 | public class ThreadPoolExecutorSubclassT
831		*/
832		public void testConstructor8() {
833		try {
834	<	new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
834	>	new CustomTPE(1, 0, 1L, SECONDS,
835	>	new ArrayBlockingQueue<Runnable>(10),
836	>	new SimpleThreadFactory());
837		shouldThrow();
838		} catch (IllegalArgumentException success) {}
839		}
#	Line 634 | Line 843 | public class ThreadPoolExecutorSubclassT
843		*/
844		public void testConstructor9() {
845		try {
846	<	new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
846	>	new CustomTPE(1, 2, -1L, SECONDS,
847	>	new ArrayBlockingQueue<Runnable>(10),
848	>	new SimpleThreadFactory());
849		shouldThrow();
850		} catch (IllegalArgumentException success) {}
851		}
#	Line 644 | Line 855 | public class ThreadPoolExecutorSubclassT
855		*/
856		public void testConstructor10() {
857		try {
858	<	new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory());
858	>	new CustomTPE(2, 1, 1L, SECONDS,
859	>	new ArrayBlockingQueue<Runnable>(10),
860	>	new SimpleThreadFactory());
861		shouldThrow();
862		} catch (IllegalArgumentException success) {}
863		}
#	Line 654 | Line 867 | public class ThreadPoolExecutorSubclassT
867		*/
868		public void testConstructorNullPointerException2() {
869		try {
870	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory());
870	>	new CustomTPE(1, 2, 1L, SECONDS, null, new SimpleThreadFactory());
871		shouldThrow();
872		} catch (NullPointerException success) {}
873		}
#	Line 664 | Line 877 | public class ThreadPoolExecutorSubclassT
877		*/
878		public void testConstructorNullPointerException3() {
879		try {
880	<	ThreadFactory f = null;
881	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
880	>	new CustomTPE(1, 2, 1L, SECONDS,
881	>	new ArrayBlockingQueue<Runnable>(10),
882	>	(ThreadFactory) null);
883		shouldThrow();
884		} catch (NullPointerException success) {}
885		}
886
673	–
887		/**
888		* Constructor throws if corePoolSize argument is less than zero
889		*/
890		public void testConstructor11() {
891		try {
892	<	new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
892	>	new CustomTPE(-1, 1, 1L, SECONDS,
893	>	new ArrayBlockingQueue<Runnable>(10),
894	>	new NoOpREHandler());
895		shouldThrow();
896		} catch (IllegalArgumentException success) {}
897		}
#	Line 686 | Line 901 | public class ThreadPoolExecutorSubclassT
901		*/
902		public void testConstructor12() {
903		try {
904	<	new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
904	>	new CustomTPE(1, -1, 1L, SECONDS,
905	>	new ArrayBlockingQueue<Runnable>(10),
906	>	new NoOpREHandler());
907		shouldThrow();
908		} catch (IllegalArgumentException success) {}
909		}
#	Line 696 | Line 913 | public class ThreadPoolExecutorSubclassT
913		*/
914		public void testConstructor13() {
915		try {
916	<	new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
916	>	new CustomTPE(1, 0, 1L, SECONDS,
917	>	new ArrayBlockingQueue<Runnable>(10),
918	>	new NoOpREHandler());
919		shouldThrow();
920		} catch (IllegalArgumentException success) {}
921		}
#	Line 706 | Line 925 | public class ThreadPoolExecutorSubclassT
925		*/
926		public void testConstructor14() {
927		try {
928	<	new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
928	>	new CustomTPE(1, 2, -1L, SECONDS,
929	>	new ArrayBlockingQueue<Runnable>(10),
930	>	new NoOpREHandler());
931		shouldThrow();
932		} catch (IllegalArgumentException success) {}
933		}
#	Line 716 | Line 937 | public class ThreadPoolExecutorSubclassT
937		*/
938		public void testConstructor15() {
939		try {
940	<	new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler());
940	>	new CustomTPE(2, 1, 1L, SECONDS,
941	>	new ArrayBlockingQueue<Runnable>(10),
942	>	new NoOpREHandler());
943		shouldThrow();
944		} catch (IllegalArgumentException success) {}
945		}
#	Line 726 | Line 949 | public class ThreadPoolExecutorSubclassT
949		*/
950		public void testConstructorNullPointerException4() {
951		try {
952	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new NoOpREHandler());
952	>	new CustomTPE(1, 2, 1L, SECONDS,
953	>	null,
954	>	new NoOpREHandler());
955		shouldThrow();
956		} catch (NullPointerException success) {}
957		}
#	Line 736 | Line 961 | public class ThreadPoolExecutorSubclassT
961		*/
962		public void testConstructorNullPointerException5() {
963		try {
964	<	RejectedExecutionHandler r = null;
965	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
964	>	new CustomTPE(1, 2, 1L, SECONDS,
965	>	new ArrayBlockingQueue<Runnable>(10),
966	>	(RejectedExecutionHandler) null);
967		shouldThrow();
968		} catch (NullPointerException success) {}
969		}
970
745	–
971		/**
972		* Constructor throws if corePoolSize argument is less than zero
973		*/
974		public void testConstructor16() {
975		try {
976	<	new CustomTPE(-1,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
976	>	new CustomTPE(-1, 1, 1L, SECONDS,
977	>	new ArrayBlockingQueue<Runnable>(10),
978	>	new SimpleThreadFactory(),
979	>	new NoOpREHandler());
980		shouldThrow();
981		} catch (IllegalArgumentException success) {}
982		}
#	Line 758 | Line 986 | public class ThreadPoolExecutorSubclassT
986		*/
987		public void testConstructor17() {
988		try {
989	<	new CustomTPE(1,-1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
989	>	new CustomTPE(1, -1, 1L, SECONDS,
990	>	new ArrayBlockingQueue<Runnable>(10),
991	>	new SimpleThreadFactory(),
992	>	new NoOpREHandler());
993		shouldThrow();
994		} catch (IllegalArgumentException success) {}
995		}
#	Line 768 | Line 999 | public class ThreadPoolExecutorSubclassT
999		*/
1000		public void testConstructor18() {
1001		try {
1002	<	new CustomTPE(1,0,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
1002	>	new CustomTPE(1, 0, 1L, SECONDS,
1003	>	new ArrayBlockingQueue<Runnable>(10),
1004	>	new SimpleThreadFactory(),
1005	>	new NoOpREHandler());
1006		shouldThrow();
1007		} catch (IllegalArgumentException success) {}
1008		}
#	Line 778 | Line 1012 | public class ThreadPoolExecutorSubclassT
1012		*/
1013		public void testConstructor19() {
1014		try {
1015	<	new CustomTPE(1,2,-1L,MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
1015	>	new CustomTPE(1, 2, -1L, SECONDS,
1016	>	new ArrayBlockingQueue<Runnable>(10),
1017	>	new SimpleThreadFactory(),
1018	>	new NoOpREHandler());
1019		shouldThrow();
1020		} catch (IllegalArgumentException success) {}
1021		}
#	Line 788 | Line 1025 | public class ThreadPoolExecutorSubclassT
1025		*/
1026		public void testConstructor20() {
1027		try {
1028	<	new CustomTPE(2,1,LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler());
1028	>	new CustomTPE(2, 1, 1L, SECONDS,
1029	>	new ArrayBlockingQueue<Runnable>(10),
1030	>	new SimpleThreadFactory(),
1031	>	new NoOpREHandler());
1032		shouldThrow();
1033		} catch (IllegalArgumentException success) {}
1034		}
1035
1036		/**
1037	<	* Constructor throws if workQueue is set to null
1037	>	* Constructor throws if workQueue is null
1038		*/
1039		public void testConstructorNullPointerException6() {
1040		try {
1041	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler());
1041	>	new CustomTPE(1, 2, 1L, SECONDS,
1042	>	null,
1043	>	new SimpleThreadFactory(),
1044	>	new NoOpREHandler());
1045		shouldThrow();
1046		} catch (NullPointerException success) {}
1047		}
1048
1049		/**
1050	<	* Constructor throws if handler is set to null
1050	>	* Constructor throws if handler is null
1051		*/
1052		public void testConstructorNullPointerException7() {
1053		try {
1054	<	RejectedExecutionHandler r = null;
1055	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r);
1054	>	new CustomTPE(1, 2, 1L, SECONDS,
1055	>	new ArrayBlockingQueue<Runnable>(10),
1056	>	new SimpleThreadFactory(),
1057	>	(RejectedExecutionHandler) null);
1058		shouldThrow();
1059		} catch (NullPointerException success) {}
1060		}
1061
1062		/**
1063	<	* Constructor throws if ThreadFactory is set top null
1063	>	* Constructor throws if ThreadFactory is null
1064		*/
1065		public void testConstructorNullPointerException8() {
1066		try {
1067	<	ThreadFactory f = null;
1068	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler());
1067	>	new CustomTPE(1, 2, 1L, SECONDS,
1068	>	new ArrayBlockingQueue<Runnable>(10),
1069	>	(ThreadFactory) null,
1070	>	new NoOpREHandler());
1071		shouldThrow();
1072		} catch (NullPointerException success) {}
1073		}
1074
828	–
1075		/**
1076	<	*  execute throws RejectedExecutionException
831	<	*  if saturated.
1076	>	* execute throws RejectedExecutionException if saturated.
1077		*/
1078		public void testSaturatedExecute() {
1079	<	ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
1080	<	try {
1081	<
1082	<	for (int i = 0; i < 5; ++i) {
1083	<	p.execute(new MediumRunnable());
1079	>	ThreadPoolExecutor p =
1080	>	new CustomTPE(1, 1,
1081	>	LONG_DELAY_MS, MILLISECONDS,
1082	>	new ArrayBlockingQueue<Runnable>(1));
1083	>	final CountDownLatch done = new CountDownLatch(1);
1084	>	try {
1085	>	Runnable task = new CheckedRunnable() {
1086	>	public void realRun() throws InterruptedException {
1087	>	done.await();
1088	>	}};
1089	>	for (int i = 0; i < 2; ++i)
1090	>	p.execute(task);
1091	>	for (int i = 0; i < 2; ++i) {
1092	>	try {
1093	>	p.execute(task);
1094	>	shouldThrow();
1095	>	} catch (RejectedExecutionException success) {}
1096	>	assertTrue(p.getTaskCount() <= 2);
1097		}
1098	<	shouldThrow();
1099	<	} catch (RejectedExecutionException success) {}
1100	<	joinPool(p);
1098	>	} finally {
1099	>	done.countDown();
1100	>	joinPool(p);
1101	>	}
1102		}
1103
1104		/**
1105	<	*  executor using CallerRunsPolicy runs task if saturated.
1105	>	* executor using CallerRunsPolicy runs task if saturated.
1106		*/
1107		public void testSaturatedExecute2() {
1108		RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
1109	<	ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1109	>	ThreadPoolExecutor p = new CustomTPE(1, 1,
1110	>	LONG_DELAY_MS, MILLISECONDS,
1111	>	new ArrayBlockingQueue<Runnable>(1),
1112	>	h);
1113		try {
852	–
1114		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1115	<	for (int i = 0; i < 5; ++i) {
1115	>	for (int i = 0; i < tasks.length; ++i)
1116		tasks[i] = new TrackedNoOpRunnable();
856	–	}
1117		TrackedLongRunnable mr = new TrackedLongRunnable();
1118		p.execute(mr);
1119	<	for (int i = 0; i < 5; ++i) {
1119	>	for (int i = 0; i < tasks.length; ++i)
1120		p.execute(tasks[i]);
1121	<	}
862	<	for (int i = 1; i < 5; ++i) {
1121	>	for (int i = 1; i < tasks.length; ++i)
1122		assertTrue(tasks[i].done);
864	–	}
1123		try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1124		} finally {
1125		joinPool(p);
#	Line 869 | Line 1127 | public class ThreadPoolExecutorSubclassT
1127		}
1128
1129		/**
1130	<	*  executor using DiscardPolicy drops task if saturated.
1130	>	* executor using DiscardPolicy drops task if saturated.
1131		*/
1132		public void testSaturatedExecute3() {
1133		RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
1134	<	ThreadPoolExecutor p = new CustomTPE(1,1, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h);
1134	>	ThreadPoolExecutor p =
1135	>	new CustomTPE(1, 1,
1136	>	LONG_DELAY_MS, MILLISECONDS,
1137	>	new ArrayBlockingQueue<Runnable>(1),
1138	>	h);
1139		try {
878	–
1140		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1141	<	for (int i = 0; i < 5; ++i) {
1141	>	for (int i = 0; i < tasks.length; ++i)
1142		tasks[i] = new TrackedNoOpRunnable();
882	–	}
1143		p.execute(new TrackedLongRunnable());
1144	<	for (int i = 0; i < 5; ++i) {
1145	<	p.execute(tasks[i]);
1146	<	}
1147	<	for (int i = 0; i < 5; ++i) {
888	<	assertFalse(tasks[i].done);
889	<	}
1144	>	for (TrackedNoOpRunnable task : tasks)
1145	>	p.execute(task);
1146	>	for (TrackedNoOpRunnable task : tasks)
1147	>	assertFalse(task.done);
1148		try { p.shutdownNow(); } catch (SecurityException ok) { return; }
1149		} finally {
1150		joinPool(p);
#	Line 894 | Line 1152 | public class ThreadPoolExecutorSubclassT
1152		}
1153
1154		/**
1155	<	*  executor using DiscardOldestPolicy drops oldest task if saturated.
1155	>	* executor using DiscardOldestPolicy drops oldest task if saturated.
1156		*/
1157		public void testSaturatedExecute4() {
1158		RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
#	Line 915 | Line 1173 | public class ThreadPoolExecutorSubclassT
1173		}
1174
1175		/**
1176	<	*  execute throws RejectedExecutionException if shutdown
1176	>	* execute throws RejectedExecutionException if shutdown
1177		*/
1178		public void testRejectedExecutionExceptionOnShutdown() {
1179	<	ThreadPoolExecutor tpe =
1179	>	ThreadPoolExecutor p =
1180		new CustomTPE(1,1,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
1181	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1181	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1182		try {
1183	<	tpe.execute(new NoOpRunnable());
1183	>	p.execute(new NoOpRunnable());
1184		shouldThrow();
1185		} catch (RejectedExecutionException success) {}
1186
1187	<	joinPool(tpe);
1187	>	joinPool(p);
1188		}
1189
1190		/**
1191	<	*  execute using CallerRunsPolicy drops task on shutdown
1191	>	* execute using CallerRunsPolicy drops task on shutdown
1192		*/
1193		public void testCallerRunsOnShutdown() {
1194		RejectedExecutionHandler h = new CustomTPE.CallerRunsPolicy();
#	Line 947 | Line 1205 | public class ThreadPoolExecutorSubclassT
1205		}
1206
1207		/**
1208	<	*  execute using DiscardPolicy drops task on shutdown
1208	>	* execute using DiscardPolicy drops task on shutdown
1209		*/
1210		public void testDiscardOnShutdown() {
1211		RejectedExecutionHandler h = new CustomTPE.DiscardPolicy();
#	Line 963 | Line 1221 | public class ThreadPoolExecutorSubclassT
1221		}
1222		}
1223
966	–
1224		/**
1225	<	*  execute using DiscardOldestPolicy drops task on shutdown
1225	>	* execute using DiscardOldestPolicy drops task on shutdown
1226		*/
1227		public void testDiscardOldestOnShutdown() {
1228		RejectedExecutionHandler h = new CustomTPE.DiscardOldestPolicy();
#	Line 981 | Line 1238 | public class ThreadPoolExecutorSubclassT
1238		}
1239		}
1240
984	–
1241		/**
1242		* execute(null) throws NPE
1243		*/
1244		public void testExecuteNull() {
1245	<	ThreadPoolExecutor tpe = null;
1245	>	ThreadPoolExecutor p =
1246	>	new CustomTPE(1, 2, 1L, SECONDS,
1247	>	new ArrayBlockingQueue<Runnable>(10));
1248		try {
1249	<	tpe = new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
992	<	tpe.execute(null);
1249	>	p.execute(null);
1250		shouldThrow();
1251		} catch (NullPointerException success) {}
1252
1253	<	joinPool(tpe);
1253	>	joinPool(p);
1254		}
1255
1256		/**
1257	<	*  setCorePoolSize of negative value throws IllegalArgumentException
1257	>	* setCorePoolSize of negative value throws IllegalArgumentException
1258		*/
1259		public void testCorePoolSizeIllegalArgumentException() {
1260	<	ThreadPoolExecutor tpe =
1260	>	ThreadPoolExecutor p =
1261		new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1262		try {
1263	<	tpe.setCorePoolSize(-1);
1263	>	p.setCorePoolSize(-1);
1264		shouldThrow();
1265		} catch (IllegalArgumentException success) {
1266		} finally {
1267	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1267	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1268		}
1269	<	joinPool(tpe);
1269	>	joinPool(p);
1270		}
1271
1272		/**
1273	<	*  setMaximumPoolSize(int) throws IllegalArgumentException if
1274	<	*  given a value less the core pool size
1273	>	* setMaximumPoolSize(int) throws IllegalArgumentException
1274	>	* if given a value less the core pool size
1275		*/
1276		public void testMaximumPoolSizeIllegalArgumentException() {
1277	<	ThreadPoolExecutor tpe =
1277	>	ThreadPoolExecutor p =
1278		new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1279		try {
1280	<	tpe.setMaximumPoolSize(1);
1280	>	p.setMaximumPoolSize(1);
1281		shouldThrow();
1282		} catch (IllegalArgumentException success) {
1283		} finally {
1284	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1284	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1285		}
1286	<	joinPool(tpe);
1286	>	joinPool(p);
1287		}
1288
1289		/**
1290	<	*  setMaximumPoolSize throws IllegalArgumentException
1291	<	*  if given a negative value
1290	>	* setMaximumPoolSize throws IllegalArgumentException
1291	>	* if given a negative value
1292		*/
1293		public void testMaximumPoolSizeIllegalArgumentException2() {
1294	<	ThreadPoolExecutor tpe =
1294	>	ThreadPoolExecutor p =
1295		new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1296		try {
1297	<	tpe.setMaximumPoolSize(-1);
1297	>	p.setMaximumPoolSize(-1);
1298		shouldThrow();
1299		} catch (IllegalArgumentException success) {
1300		} finally {
1301	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1301	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1302		}
1303	<	joinPool(tpe);
1303	>	joinPool(p);
1304		}
1305
1049	–
1306		/**
1307	<	*  setKeepAliveTime  throws IllegalArgumentException
1308	<	*  when given a negative value
1307	>	* setKeepAliveTime throws IllegalArgumentException
1308	>	* when given a negative value
1309		*/
1310		public void testKeepAliveTimeIllegalArgumentException() {
1311	<	ThreadPoolExecutor tpe =
1311	>	ThreadPoolExecutor p =
1312		new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1313
1314		try {
1315	<	tpe.setKeepAliveTime(-1,MILLISECONDS);
1315	>	p.setKeepAliveTime(-1,MILLISECONDS);
1316		shouldThrow();
1317		} catch (IllegalArgumentException success) {
1318		} finally {
1319	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1319	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1320		}
1321	<	joinPool(tpe);
1321	>	joinPool(p);
1322		}
1323
1324		/**
1325		* terminated() is called on termination
1326		*/
1327		public void testTerminated() {
1328	<	CustomTPE tpe = new CustomTPE();
1329	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1330	<	assertTrue(tpe.terminatedCalled);
1331	<	joinPool(tpe);
1328	>	CustomTPE p = new CustomTPE();
1329	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1330	>	assertTrue(p.terminatedCalled());
1331	>	joinPool(p);
1332		}
1333
1334		/**
1335		* beforeExecute and afterExecute are called when executing task
1336		*/
1337		public void testBeforeAfter() throws InterruptedException {
1338	<	CustomTPE tpe = new CustomTPE();
1338	>	CustomTPE p = new CustomTPE();
1339		try {
1340	<	TrackedNoOpRunnable r = new TrackedNoOpRunnable();
1341	<	tpe.execute(r);
1342	<	Thread.sleep(SHORT_DELAY_MS);
1343	<	assertTrue(r.done);
1344	<	assertTrue(tpe.beforeCalled);
1345	<	assertTrue(tpe.afterCalled);
1346	<	try { tpe.shutdown(); } catch (SecurityException ok) { return; }
1340	>	final CountDownLatch done = new CountDownLatch(1);
1341	>	p.execute(new CheckedRunnable() {
1342	>	public void realRun() {
1343	>	done.countDown();
1344	>	}});
1345	>	await(p.afterCalled);
1346	>	assertEquals(0, done.getCount());
1347	>	assertTrue(p.afterCalled());
1348	>	assertTrue(p.beforeCalled());
1349	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1350		} finally {
1351	<	joinPool(tpe);
1351	>	joinPool(p);
1352		}
1353		}
1354
#	Line 1135 | Line 1394 | public class ThreadPoolExecutorSubclassT
1394		}
1395		}
1396
1138	–
1397		/**
1398		* invokeAny(null) throws NPE
1399		*/
#	Line 1297 | Line 1555 | public class ThreadPoolExecutorSubclassT
1555		}
1556		}
1557
1300	–
1301	–
1558		/**
1559		* timed invokeAny(null) throws NPE
1560		*/
#	Line 1500 | Line 1756 | public class ThreadPoolExecutorSubclassT
1756		public void testTimedInvokeAll6() throws Exception {
1757		ExecutorService e = new CustomTPE(2, 2, LONG_DELAY_MS, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1758		try {
1759	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1760	<	l.add(new StringTask());
1761	<	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1762	<	l.add(new StringTask());
1763	<	List<Future<String>> futures =
1764	<	e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1765	<	assertEquals(3, futures.size());
1766	<	Iterator<Future<String>> it = futures.iterator();
1767	<	Future<String> f1 = it.next();
1768	<	Future<String> f2 = it.next();
1769	<	Future<String> f3 = it.next();
1770	<	assertTrue(f1.isDone());
1771	<	assertTrue(f2.isDone());
1772	<	assertTrue(f3.isDone());
1773	<	assertFalse(f1.isCancelled());
1774	<	assertTrue(f2.isCancelled());
1759	>	for (long timeout = timeoutMillis();;) {
1760	>	List<Callable<String>> tasks = new ArrayList<>();
1761	>	tasks.add(new StringTask("0"));
1762	>	tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1763	>	tasks.add(new StringTask("2"));
1764	>	long startTime = System.nanoTime();
1765	>	List<Future<String>> futures =
1766	>	e.invokeAll(tasks, timeout, MILLISECONDS);
1767	>	assertEquals(tasks.size(), futures.size());
1768	>	assertTrue(millisElapsedSince(startTime) >= timeout);
1769	>	for (Future future : futures)
1770	>	assertTrue(future.isDone());
1771	>	assertTrue(futures.get(1).isCancelled());
1772	>	try {
1773	>	assertEquals("0", futures.get(0).get());
1774	>	assertEquals("2", futures.get(2).get());
1775	>	break;
1776	>	} catch (CancellationException retryWithLongerTimeout) {
1777	>	timeout *= 2;
1778	>	if (timeout >= LONG_DELAY_MS / 2)
1779	>	fail("expected exactly one task to be cancelled");
1780	>	}
1781	>	}
1782		} finally {
1783		joinPool(e);
1784		}
#	Line 1526 | Line 1789 | public class ThreadPoolExecutorSubclassT
1789		* thread factory fails to create more
1790		*/
1791		public void testFailingThreadFactory() throws InterruptedException {
1792	<	ExecutorService e = new CustomTPE(100, 100, LONG_DELAY_MS, MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory());
1793	<	try {
1794	<	for (int k = 0; k < 100; ++k) {
1795	<	e.execute(new NoOpRunnable());
1796	<	}
1797	<	Thread.sleep(LONG_DELAY_MS);
1792	>	final ExecutorService e =
1793	>	new CustomTPE(100, 100,
1794	>	LONG_DELAY_MS, MILLISECONDS,
1795	>	new LinkedBlockingQueue<Runnable>(),
1796	>	new FailingThreadFactory());
1797	>	try {
1798	>	final int TASKS = 100;
1799	>	final CountDownLatch done = new CountDownLatch(TASKS);
1800	>	for (int k = 0; k < TASKS; ++k)
1801	>	e.execute(new CheckedRunnable() {
1802	>	public void realRun() {
1803	>	done.countDown();
1804	>	}});
1805	>	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1806		} finally {
1807		joinPool(e);
1808		}
#	Line 1541 | Line 1812 | public class ThreadPoolExecutorSubclassT
1812		* allowsCoreThreadTimeOut is by default false.
1813		*/
1814		public void testAllowsCoreThreadTimeOut() {
1815	<	ThreadPoolExecutor tpe = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1816	<	assertFalse(tpe.allowsCoreThreadTimeOut());
1817	<	joinPool(tpe);
1815	>	ThreadPoolExecutor p = new CustomTPE(2, 2, 1000, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1816	>	assertFalse(p.allowsCoreThreadTimeOut());
1817	>	joinPool(p);
1818		}
1819
1820		/**
1821		* allowCoreThreadTimeOut(true) causes idle threads to time out
1822		*/
1823	<	public void testAllowCoreThreadTimeOut_true() throws InterruptedException {
1824	<	ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1825	<	tpe.allowCoreThreadTimeOut(true);
1826	<	tpe.execute(new NoOpRunnable());
1827	<	try {
1828	<	Thread.sleep(MEDIUM_DELAY_MS);
1829	<	assertEquals(0, tpe.getPoolSize());
1823	>	public void testAllowCoreThreadTimeOut_true() throws Exception {
1824	>	long keepAliveTime = timeoutMillis();
1825	>	final ThreadPoolExecutor p =
1826	>	new CustomTPE(2, 10,
1827	>	keepAliveTime, MILLISECONDS,
1828	>	new ArrayBlockingQueue<Runnable>(10));
1829	>	final CountDownLatch threadStarted = new CountDownLatch(1);
1830	>	try {
1831	>	p.allowCoreThreadTimeOut(true);
1832	>	p.execute(new CheckedRunnable() {
1833	>	public void realRun() {
1834	>	threadStarted.countDown();
1835	>	assertEquals(1, p.getPoolSize());
1836	>	}});
1837	>	await(threadStarted);
1838	>	delay(keepAliveTime);
1839	>	long startTime = System.nanoTime();
1840	>	while (p.getPoolSize() > 0
1841	>	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
1842	>	Thread.yield();
1843	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1844	>	assertEquals(0, p.getPoolSize());
1845		} finally {
1846	<	joinPool(tpe);
1846	>	joinPool(p);
1847		}
1848		}
1849
1850		/**
1851		* allowCoreThreadTimeOut(false) causes idle threads not to time out
1852		*/
1853	<	public void testAllowCoreThreadTimeOut_false() throws InterruptedException {
1854	<	ThreadPoolExecutor tpe = new CustomTPE(2, 10, 10, MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
1855	<	tpe.allowCoreThreadTimeOut(false);
1856	<	tpe.execute(new NoOpRunnable());
1857	<	try {
1858	<	Thread.sleep(MEDIUM_DELAY_MS);
1859	<	assertTrue(tpe.getPoolSize() >= 1);
1853	>	public void testAllowCoreThreadTimeOut_false() throws Exception {
1854	>	long keepAliveTime = timeoutMillis();
1855	>	final ThreadPoolExecutor p =
1856	>	new CustomTPE(2, 10,
1857	>	keepAliveTime, MILLISECONDS,
1858	>	new ArrayBlockingQueue<Runnable>(10));
1859	>	final CountDownLatch threadStarted = new CountDownLatch(1);
1860	>	try {
1861	>	p.allowCoreThreadTimeOut(false);
1862	>	p.execute(new CheckedRunnable() {
1863	>	public void realRun() throws InterruptedException {
1864	>	threadStarted.countDown();
1865	>	assertTrue(p.getPoolSize() >= 1);
1866	>	}});
1867	>	delay(2 * keepAliveTime);
1868	>	assertTrue(p.getPoolSize() >= 1);
1869		} finally {
1870	<	joinPool(tpe);
1870	>	joinPool(p);
1871		}
1872		}
1873

Diff Legend

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