ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.46 by jsr166, Sun May 29 13:55:36 2011 UTC vs.
Revision 1.68 by jsr166, Sun Oct 4 01:27:32 2015 UTC

#	Line 6 | Line 6
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.atomic.*;
11	<	import junit.framework.*;
12	<	import java.util.*;
10	>	import static java.util.concurrent.TimeUnit.NANOSECONDS;
11	>	import static java.util.concurrent.TimeUnit.SECONDS;
12	>
13	>	import java.util.ArrayList;
14	>	import java.util.List;
15	>	import java.util.concurrent.ArrayBlockingQueue;
16	>	import java.util.concurrent.BlockingQueue;
17	>	import java.util.concurrent.Callable;
18	>	import java.util.concurrent.CancellationException;
19	>	import java.util.concurrent.CountDownLatch;
20	>	import java.util.concurrent.ExecutionException;
21	>	import java.util.concurrent.Executors;
22	>	import java.util.concurrent.ExecutorService;
23	>	import java.util.concurrent.Future;
24	>	import java.util.concurrent.FutureTask;
25	>	import java.util.concurrent.LinkedBlockingQueue;
26	>	import java.util.concurrent.RejectedExecutionException;
27	>	import java.util.concurrent.RejectedExecutionHandler;
28	>	import java.util.concurrent.SynchronousQueue;
29	>	import java.util.concurrent.ThreadFactory;
30	>	import java.util.concurrent.ThreadPoolExecutor;
31	>	import java.util.concurrent.TimeUnit;
32	>	import java.util.concurrent.atomic.AtomicInteger;
33	>
34	>	import junit.framework.Test;
35	>	import junit.framework.TestSuite;
36
37		public class ThreadPoolExecutorTest extends JSR166TestCase {
38		public static void main(String[] args) {
39	<	junit.textui.TestRunner.run(suite());
39	>	main(suite(), args);
40		}
41		public static Test suite() {
42		return new TestSuite(ThreadPoolExecutorTest.class);
#	Line 110 | Line 132 | public class ThreadPoolExecutorTest exte
132		*/
133		public void testPrestartCoreThread() {
134		final ThreadPoolExecutor p =
135	<	new ThreadPoolExecutor(2, 2,
135	>	new ThreadPoolExecutor(2, 6,
136		LONG_DELAY_MS, MILLISECONDS,
137		new ArrayBlockingQueue<Runnable>(10));
138	<	assertEquals(0, p.getPoolSize());
139	<	assertTrue(p.prestartCoreThread());
140	<	assertEquals(1, p.getPoolSize());
141	<	assertTrue(p.prestartCoreThread());
142	<	assertEquals(2, p.getPoolSize());
143	<	assertFalse(p.prestartCoreThread());
144	<	assertEquals(2, p.getPoolSize());
145	<	joinPool(p);
138	>	try (PoolCleaner cleaner = cleaner(p)) {
139	>	assertEquals(0, p.getPoolSize());
140	>	assertTrue(p.prestartCoreThread());
141	>	assertEquals(1, p.getPoolSize());
142	>	assertTrue(p.prestartCoreThread());
143	>	assertEquals(2, p.getPoolSize());
144	>	assertFalse(p.prestartCoreThread());
145	>	assertEquals(2, p.getPoolSize());
146	>	p.setCorePoolSize(4);
147	>	assertTrue(p.prestartCoreThread());
148	>	assertEquals(3, p.getPoolSize());
149	>	assertTrue(p.prestartCoreThread());
150	>	assertEquals(4, p.getPoolSize());
151	>	assertFalse(p.prestartCoreThread());
152	>	assertEquals(4, p.getPoolSize());
153	>	}
154		}
155
156		/**
#	Line 128 | Line 158 | public class ThreadPoolExecutorTest exte
158		*/
159		public void testPrestartAllCoreThreads() {
160		final ThreadPoolExecutor p =
161	<	new ThreadPoolExecutor(2, 2,
161	>	new ThreadPoolExecutor(2, 6,
162		LONG_DELAY_MS, MILLISECONDS,
163		new ArrayBlockingQueue<Runnable>(10));
164	<	assertEquals(0, p.getPoolSize());
165	<	p.prestartAllCoreThreads();
166	<	assertEquals(2, p.getPoolSize());
167	<	p.prestartAllCoreThreads();
168	<	assertEquals(2, p.getPoolSize());
169	<	joinPool(p);
164	>	try (PoolCleaner cleaner = cleaner(p)) {
165	>	assertEquals(0, p.getPoolSize());
166	>	p.prestartAllCoreThreads();
167	>	assertEquals(2, p.getPoolSize());
168	>	p.prestartAllCoreThreads();
169	>	assertEquals(2, p.getPoolSize());
170	>	p.setCorePoolSize(4);
171	>	p.prestartAllCoreThreads();
172	>	assertEquals(4, p.getPoolSize());
173	>	p.prestartAllCoreThreads();
174	>	assertEquals(4, p.getPoolSize());
175	>	}
176		}
177
178		/**
#	Line 148 | Line 184 | public class ThreadPoolExecutorTest exte
184		new ThreadPoolExecutor(2, 2,
185		LONG_DELAY_MS, MILLISECONDS,
186		new ArrayBlockingQueue<Runnable>(10));
187	<	final CountDownLatch threadStarted = new CountDownLatch(1);
188	<	final CountDownLatch threadProceed = new CountDownLatch(1);
189	<	final CountDownLatch threadDone = new CountDownLatch(1);
190	<	try {
187	>	try (PoolCleaner cleaner = cleaner(p)) {
188	>	final CountDownLatch threadStarted = new CountDownLatch(1);
189	>	final CountDownLatch threadProceed = new CountDownLatch(1);
190	>	final CountDownLatch threadDone = new CountDownLatch(1);
191		assertEquals(0, p.getCompletedTaskCount());
192		p.execute(new CheckedRunnable() {
193		public void realRun() throws InterruptedException {
#	Line 170 | Line 206 | public class ThreadPoolExecutorTest exte
206		fail("timed out");
207		Thread.yield();
208		}
173	–	} finally {
174	–	joinPool(p);
209		}
210		}
211
#	Line 195 | Line 229 | public class ThreadPoolExecutorTest exte
229		new ThreadPoolExecutor(2, 2,
230		1000, MILLISECONDS,
231		new ArrayBlockingQueue<Runnable>(10));
232	<	assertEquals(1, p.getKeepAliveTime(TimeUnit.SECONDS));
232	>	assertEquals(1, p.getKeepAliveTime(SECONDS));
233		joinPool(p);
234		}
235
#	Line 402 | Line 436 | public class ThreadPoolExecutorTest exte
436		}
437
438		/**
439	+	* awaitTermination on a non-shutdown pool times out
440	+	*/
441	+	public void testAwaitTermination_timesOut() throws InterruptedException {
442	+	final ThreadPoolExecutor p =
443	+	new ThreadPoolExecutor(1, 1,
444	+	LONG_DELAY_MS, MILLISECONDS,
445	+	new ArrayBlockingQueue<Runnable>(10));
446	+	assertFalse(p.isTerminated());
447	+	assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
448	+	assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
449	+	assertFalse(p.awaitTermination(-1L, NANOSECONDS));
450	+	assertFalse(p.awaitTermination(-1L, MILLISECONDS));
451	+	assertFalse(p.awaitTermination(0L, NANOSECONDS));
452	+	assertFalse(p.awaitTermination(0L, MILLISECONDS));
453	+	long timeoutNanos = 999999L;
454	+	long startTime = System.nanoTime();
455	+	assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
456	+	assertTrue(System.nanoTime() - startTime >= timeoutNanos);
457	+	assertFalse(p.isTerminated());
458	+	startTime = System.nanoTime();
459	+	long timeoutMillis = timeoutMillis();
460	+	assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
461	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
462	+	assertFalse(p.isTerminated());
463	+	p.shutdown();
464	+	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
465	+	assertTrue(p.isTerminated());
466	+	}
467	+
468	+	/**
469		* isTerminated is false before termination, true after
470		*/
471		public void testIsTerminated() throws InterruptedException {
#	Line 573 | Line 637 | public class ThreadPoolExecutorTest exte
637		}
638
639		/**
640	<	* shutdownNow returns a list containing tasks that were not run
640	>	* shutdownNow returns a list containing tasks that were not run,
641	>	* and those tasks are drained from the queue
642		*/
643	<	public void testShutdownNow() {
643	>	public void testShutdownNow() throws InterruptedException {
644	>	final int poolSize = 2;
645	>	final int count = 5;
646	>	final AtomicInteger ran = new AtomicInteger(0);
647		final ThreadPoolExecutor p =
648	<	new ThreadPoolExecutor(1, 1,
648	>	new ThreadPoolExecutor(poolSize, poolSize,
649		LONG_DELAY_MS, MILLISECONDS,
650		new ArrayBlockingQueue<Runnable>(10));
651	<	List l;
652	<	try {
653	<	for (int i = 0; i < 5; i++)
586	<	p.execute(new MediumPossiblyInterruptedRunnable());
587	<	}
588	<	finally {
651	>	CountDownLatch threadsStarted = new CountDownLatch(poolSize);
652	>	Runnable waiter = new CheckedRunnable() { public void realRun() {
653	>	threadsStarted.countDown();
654		try {
655	<	l = p.shutdownNow();
656	<	} catch (SecurityException ok) { return; }
655	>	MILLISECONDS.sleep(2 * LONG_DELAY_MS);
656	>	} catch (InterruptedException success) {}
657	>	ran.getAndIncrement();
658	>	}};
659	>	for (int i = 0; i < count; i++)
660	>	p.execute(waiter);
661	>	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
662	>	assertEquals(poolSize, p.getActiveCount());
663	>	assertEquals(0, p.getCompletedTaskCount());
664	>	final List<Runnable> queuedTasks;
665	>	try {
666	>	queuedTasks = p.shutdownNow();
667	>	} catch (SecurityException ok) {
668	>	return; // Allowed in case test doesn't have privs
669		}
670		assertTrue(p.isShutdown());
671	<	assertTrue(l.size() <= 4);
671	>	assertTrue(p.getQueue().isEmpty());
672	>	assertEquals(count - poolSize, queuedTasks.size());
673	>	assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
674	>	assertTrue(p.isTerminated());
675	>	assertEquals(poolSize, ran.get());
676	>	assertEquals(poolSize, p.getCompletedTaskCount());
677		}
678
679		// Exception Tests
#	Line 601 | Line 683 | public class ThreadPoolExecutorTest exte
683		*/
684		public void testConstructor1() {
685		try {
686	<	new ThreadPoolExecutor(-1, 1,
605	<	LONG_DELAY_MS, MILLISECONDS,
686	>	new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
687		new ArrayBlockingQueue<Runnable>(10));
688		shouldThrow();
689		} catch (IllegalArgumentException success) {}
#	Line 613 | Line 694 | public class ThreadPoolExecutorTest exte
694		*/
695		public void testConstructor2() {
696		try {
697	<	new ThreadPoolExecutor(1, -1,
617	<	LONG_DELAY_MS, MILLISECONDS,
697	>	new ThreadPoolExecutor(1, -1, 1L, SECONDS,
698		new ArrayBlockingQueue<Runnable>(10));
699		shouldThrow();
700		} catch (IllegalArgumentException success) {}
#	Line 625 | Line 705 | public class ThreadPoolExecutorTest exte
705		*/
706		public void testConstructor3() {
707		try {
708	<	new ThreadPoolExecutor(1, 0,
629	<	LONG_DELAY_MS, MILLISECONDS,
708	>	new ThreadPoolExecutor(1, 0, 1L, SECONDS,
709		new ArrayBlockingQueue<Runnable>(10));
710		shouldThrow();
711		} catch (IllegalArgumentException success) {}
#	Line 637 | Line 716 | public class ThreadPoolExecutorTest exte
716		*/
717		public void testConstructor4() {
718		try {
719	<	new ThreadPoolExecutor(1, 2,
641	<	-1L, MILLISECONDS,
719	>	new ThreadPoolExecutor(1, 2, -1L, SECONDS,
720		new ArrayBlockingQueue<Runnable>(10));
721		shouldThrow();
722		} catch (IllegalArgumentException success) {}
#	Line 649 | Line 727 | public class ThreadPoolExecutorTest exte
727		*/
728		public void testConstructor5() {
729		try {
730	<	new ThreadPoolExecutor(2, 1,
653	<	LONG_DELAY_MS, MILLISECONDS,
730	>	new ThreadPoolExecutor(2, 1, 1L, SECONDS,
731		new ArrayBlockingQueue<Runnable>(10));
732		shouldThrow();
733		} catch (IllegalArgumentException success) {}
#	Line 661 | Line 738 | public class ThreadPoolExecutorTest exte
738		*/
739		public void testConstructorNullPointerException() {
740		try {
741	<	new ThreadPoolExecutor(1, 2,
665	<	LONG_DELAY_MS, MILLISECONDS,
741	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
742		(BlockingQueue) null);
743		shouldThrow();
744		} catch (NullPointerException success) {}
#	Line 673 | Line 749 | public class ThreadPoolExecutorTest exte
749		*/
750		public void testConstructor6() {
751		try {
752	<	new ThreadPoolExecutor(-1, 1,
677	<	LONG_DELAY_MS, MILLISECONDS,
752	>	new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
753		new ArrayBlockingQueue<Runnable>(10),
754		new SimpleThreadFactory());
755		shouldThrow();
#	Line 686 | Line 761 | public class ThreadPoolExecutorTest exte
761		*/
762		public void testConstructor7() {
763		try {
764	<	new ThreadPoolExecutor(1, -1,
690	<	LONG_DELAY_MS, MILLISECONDS,
764	>	new ThreadPoolExecutor(1, -1, 1L, SECONDS,
765		new ArrayBlockingQueue<Runnable>(10),
766		new SimpleThreadFactory());
767		shouldThrow();
#	Line 699 | Line 773 | public class ThreadPoolExecutorTest exte
773		*/
774		public void testConstructor8() {
775		try {
776	<	new ThreadPoolExecutor(1, 0,
703	<	LONG_DELAY_MS, MILLISECONDS,
776	>	new ThreadPoolExecutor(1, 0, 1L, SECONDS,
777		new ArrayBlockingQueue<Runnable>(10),
778		new SimpleThreadFactory());
779		shouldThrow();
#	Line 712 | Line 785 | public class ThreadPoolExecutorTest exte
785		*/
786		public void testConstructor9() {
787		try {
788	<	new ThreadPoolExecutor(1, 2,
716	<	-1L, MILLISECONDS,
788	>	new ThreadPoolExecutor(1, 2, -1L, SECONDS,
789		new ArrayBlockingQueue<Runnable>(10),
790		new SimpleThreadFactory());
791		shouldThrow();
#	Line 725 | Line 797 | public class ThreadPoolExecutorTest exte
797		*/
798		public void testConstructor10() {
799		try {
800	<	new ThreadPoolExecutor(2, 1,
729	<	LONG_DELAY_MS, MILLISECONDS,
800	>	new ThreadPoolExecutor(2, 1, 1L, SECONDS,
801		new ArrayBlockingQueue<Runnable>(10),
802		new SimpleThreadFactory());
803		shouldThrow();
#	Line 738 | Line 809 | public class ThreadPoolExecutorTest exte
809		*/
810		public void testConstructorNullPointerException2() {
811		try {
812	<	new ThreadPoolExecutor(1, 2,
742	<	LONG_DELAY_MS, MILLISECONDS,
812	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
813		(BlockingQueue) null,
814		new SimpleThreadFactory());
815		shouldThrow();
#	Line 751 | Line 821 | public class ThreadPoolExecutorTest exte
821		*/
822		public void testConstructorNullPointerException3() {
823		try {
824	<	new ThreadPoolExecutor(1, 2,
755	<	LONG_DELAY_MS, MILLISECONDS,
824	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
825		new ArrayBlockingQueue<Runnable>(10),
826		(ThreadFactory) null);
827		shouldThrow();
#	Line 764 | Line 833 | public class ThreadPoolExecutorTest exte
833		*/
834		public void testConstructor11() {
835		try {
836	<	new ThreadPoolExecutor(-1, 1,
768	<	LONG_DELAY_MS, MILLISECONDS,
836	>	new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
837		new ArrayBlockingQueue<Runnable>(10),
838		new NoOpREHandler());
839		shouldThrow();
#	Line 777 | Line 845 | public class ThreadPoolExecutorTest exte
845		*/
846		public void testConstructor12() {
847		try {
848	<	new ThreadPoolExecutor(1, -1,
781	<	LONG_DELAY_MS, MILLISECONDS,
848	>	new ThreadPoolExecutor(1, -1, 1L, SECONDS,
849		new ArrayBlockingQueue<Runnable>(10),
850		new NoOpREHandler());
851		shouldThrow();
#	Line 790 | Line 857 | public class ThreadPoolExecutorTest exte
857		*/
858		public void testConstructor13() {
859		try {
860	<	new ThreadPoolExecutor(1, 0,
794	<	LONG_DELAY_MS, MILLISECONDS,
860	>	new ThreadPoolExecutor(1, 0, 1L, SECONDS,
861		new ArrayBlockingQueue<Runnable>(10),
862		new NoOpREHandler());
863		shouldThrow();
#	Line 803 | Line 869 | public class ThreadPoolExecutorTest exte
869		*/
870		public void testConstructor14() {
871		try {
872	<	new ThreadPoolExecutor(1, 2,
807	<	-1L, MILLISECONDS,
872	>	new ThreadPoolExecutor(1, 2, -1L, SECONDS,
873		new ArrayBlockingQueue<Runnable>(10),
874		new NoOpREHandler());
875		shouldThrow();
#	Line 816 | Line 881 | public class ThreadPoolExecutorTest exte
881		*/
882		public void testConstructor15() {
883		try {
884	<	new ThreadPoolExecutor(2, 1,
820	<	LONG_DELAY_MS, MILLISECONDS,
884	>	new ThreadPoolExecutor(2, 1, 1L, SECONDS,
885		new ArrayBlockingQueue<Runnable>(10),
886		new NoOpREHandler());
887		shouldThrow();
#	Line 829 | Line 893 | public class ThreadPoolExecutorTest exte
893		*/
894		public void testConstructorNullPointerException4() {
895		try {
896	<	new ThreadPoolExecutor(1, 2,
833	<	LONG_DELAY_MS, MILLISECONDS,
896	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
897		(BlockingQueue) null,
898		new NoOpREHandler());
899		shouldThrow();
#	Line 842 | Line 905 | public class ThreadPoolExecutorTest exte
905		*/
906		public void testConstructorNullPointerException5() {
907		try {
908	<	new ThreadPoolExecutor(1, 2,
846	<	LONG_DELAY_MS, MILLISECONDS,
908	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
909		new ArrayBlockingQueue<Runnable>(10),
910		(RejectedExecutionHandler) null);
911		shouldThrow();
#	Line 855 | Line 917 | public class ThreadPoolExecutorTest exte
917		*/
918		public void testConstructor16() {
919		try {
920	<	new ThreadPoolExecutor(-1, 1,
859	<	LONG_DELAY_MS, MILLISECONDS,
920	>	new ThreadPoolExecutor(-1, 1, 1L, SECONDS,
921		new ArrayBlockingQueue<Runnable>(10),
922		new SimpleThreadFactory(),
923		new NoOpREHandler());
#	Line 869 | Line 930 | public class ThreadPoolExecutorTest exte
930		*/
931		public void testConstructor17() {
932		try {
933	<	new ThreadPoolExecutor(1, -1,
873	<	LONG_DELAY_MS, MILLISECONDS,
933	>	new ThreadPoolExecutor(1, -1, 1L, SECONDS,
934		new ArrayBlockingQueue<Runnable>(10),
935		new SimpleThreadFactory(),
936		new NoOpREHandler());
#	Line 883 | Line 943 | public class ThreadPoolExecutorTest exte
943		*/
944		public void testConstructor18() {
945		try {
946	<	new ThreadPoolExecutor(1, 0,
887	<	LONG_DELAY_MS, MILLISECONDS,
946	>	new ThreadPoolExecutor(1, 0, 1L, SECONDS,
947		new ArrayBlockingQueue<Runnable>(10),
948		new SimpleThreadFactory(),
949		new NoOpREHandler());
#	Line 897 | Line 956 | public class ThreadPoolExecutorTest exte
956		*/
957		public void testConstructor19() {
958		try {
959	<	new ThreadPoolExecutor(1, 2,
901	<	-1L, MILLISECONDS,
959	>	new ThreadPoolExecutor(1, 2, -1L, SECONDS,
960		new ArrayBlockingQueue<Runnable>(10),
961		new SimpleThreadFactory(),
962		new NoOpREHandler());
#	Line 911 | Line 969 | public class ThreadPoolExecutorTest exte
969		*/
970		public void testConstructor20() {
971		try {
972	<	new ThreadPoolExecutor(2, 1,
915	<	LONG_DELAY_MS, MILLISECONDS,
972	>	new ThreadPoolExecutor(2, 1, 1L, SECONDS,
973		new ArrayBlockingQueue<Runnable>(10),
974		new SimpleThreadFactory(),
975		new NoOpREHandler());
#	Line 925 | Line 982 | public class ThreadPoolExecutorTest exte
982		*/
983		public void testConstructorNullPointerException6() {
984		try {
985	<	new ThreadPoolExecutor(1, 2,
929	<	LONG_DELAY_MS, MILLISECONDS,
985	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
986		(BlockingQueue) null,
987		new SimpleThreadFactory(),
988		new NoOpREHandler());
#	Line 939 | Line 995 | public class ThreadPoolExecutorTest exte
995		*/
996		public void testConstructorNullPointerException7() {
997		try {
998	<	new ThreadPoolExecutor(1, 2,
943	<	LONG_DELAY_MS, MILLISECONDS,
998	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
999		new ArrayBlockingQueue<Runnable>(10),
1000		new SimpleThreadFactory(),
1001		(RejectedExecutionHandler) null);
#	Line 953 | Line 1008 | public class ThreadPoolExecutorTest exte
1008		*/
1009		public void testConstructorNullPointerException8() {
1010		try {
1011	<	new ThreadPoolExecutor(1, 2,
957	<	LONG_DELAY_MS, MILLISECONDS,
1011	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1012		new ArrayBlockingQueue<Runnable>(10),
1013		(ThreadFactory) null,
1014		new NoOpREHandler());
#	Line 968 | Line 1022 | public class ThreadPoolExecutorTest exte
1022		public void testInterruptedSubmit() throws InterruptedException {
1023		final ThreadPoolExecutor p =
1024		new ThreadPoolExecutor(1, 1,
1025	<	60, TimeUnit.SECONDS,
1025	>	60, SECONDS,
1026		new ArrayBlockingQueue<Runnable>(10));
1027
1028		final CountDownLatch threadStarted = new CountDownLatch(1);
#	Line 1242 | Line 1296 | public class ThreadPoolExecutorTest exte
1296		*/
1297		public void testExecuteNull() {
1298		ThreadPoolExecutor p =
1299	<	new ThreadPoolExecutor(1, 2,
1246	<	LONG_DELAY_MS, MILLISECONDS,
1299	>	new ThreadPoolExecutor(1, 2, 1L, SECONDS,
1300		new ArrayBlockingQueue<Runnable>(10));
1301		try {
1302		p.execute(null);
#	Line 1310 | Line 1363 | public class ThreadPoolExecutorTest exte
1363		}
1364
1365		/**
1366	+	* Configuration changes that allow core pool size greater than
1367	+	* max pool size result in IllegalArgumentException.
1368	+	*/
1369	+	public void testPoolSizeInvariants() {
1370	+	ThreadPoolExecutor p =
1371	+	new ThreadPoolExecutor(1, 1,
1372	+	LONG_DELAY_MS, MILLISECONDS,
1373	+	new ArrayBlockingQueue<Runnable>(10));
1374	+	for (int s = 1; s < 5; s++) {
1375	+	p.setMaximumPoolSize(s);
1376	+	p.setCorePoolSize(s);
1377	+	try {
1378	+	p.setMaximumPoolSize(s - 1);
1379	+	shouldThrow();
1380	+	} catch (IllegalArgumentException success) {}
1381	+	assertEquals(s, p.getCorePoolSize());
1382	+	assertEquals(s, p.getMaximumPoolSize());
1383	+	try {
1384	+	p.setCorePoolSize(s + 1);
1385	+	shouldThrow();
1386	+	} catch (IllegalArgumentException success) {}
1387	+	assertEquals(s, p.getCorePoolSize());
1388	+	assertEquals(s, p.getMaximumPoolSize());
1389	+	}
1390	+	joinPool(p);
1391	+	}
1392	+
1393	+	/**
1394		* setKeepAliveTime throws IllegalArgumentException
1395		* when given a negative value
1396		*/
#	Line 1345 | Line 1426 | public class ThreadPoolExecutorTest exte
1426		ExtendedTPE p = new ExtendedTPE();
1427		try {
1428		final CountDownLatch done = new CountDownLatch(1);
1429	<	final CheckedRunnable task = new CheckedRunnable() {
1429	>	p.execute(new CheckedRunnable() {
1430		public void realRun() {
1431		done.countDown();
1432	<	}};
1352	<	p.execute(task);
1432	>	}});
1433		await(p.afterCalled);
1434		assertEquals(0, done.getCount());
1435		assertTrue(p.afterCalled());
#	Line 1826 | Line 1906 | public class ThreadPoolExecutorTest exte
1906		l.add(new StringTask());
1907		l.add(new StringTask());
1908		List<Future<String>> futures =
1909	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1909	>	e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1910		assertEquals(2, futures.size());
1911		for (Future<String> future : futures)
1912		assertSame(TEST_STRING, future.get());
#	Line 1844 | Line 1924 | public class ThreadPoolExecutorTest exte
1924		LONG_DELAY_MS, MILLISECONDS,
1925		new ArrayBlockingQueue<Runnable>(10));
1926		try {
1927	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1928	<	l.add(new StringTask());
1929	<	l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
1930	<	l.add(new StringTask());
1931	<	List<Future<String>> futures =
1932	<	e.invokeAll(l, SHORT_DELAY_MS, MILLISECONDS);
1933	<	assertEquals(l.size(), futures.size());
1934	<	for (Future future : futures)
1935	<	assertTrue(future.isDone());
1936	<	assertFalse(futures.get(0).isCancelled());
1937	<	assertTrue(futures.get(1).isCancelled());
1927	>	for (long timeout = timeoutMillis();;) {
1928	>	List<Callable<String>> tasks = new ArrayList<>();
1929	>	tasks.add(new StringTask("0"));
1930	>	tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1931	>	tasks.add(new StringTask("2"));
1932	>	long startTime = System.nanoTime();
1933	>	List<Future<String>> futures =
1934	>	e.invokeAll(tasks, timeout, MILLISECONDS);
1935	>	assertEquals(tasks.size(), futures.size());
1936	>	assertTrue(millisElapsedSince(startTime) >= timeout);
1937	>	for (Future future : futures)
1938	>	assertTrue(future.isDone());
1939	>	assertTrue(futures.get(1).isCancelled());
1940	>	try {
1941	>	assertEquals("0", futures.get(0).get());
1942	>	assertEquals("2", futures.get(2).get());
1943	>	break;
1944	>	} catch (CancellationException retryWithLongerTimeout) {
1945	>	timeout *= 2;
1946	>	if (timeout >= LONG_DELAY_MS / 2)
1947	>	fail("expected exactly one task to be cancelled");
1948	>	}
1949	>	}
1950		} finally {
1951		joinPool(e);
1952		}
#	Line 1900 | Line 1992 | public class ThreadPoolExecutorTest exte
1992		* allowCoreThreadTimeOut(true) causes idle threads to time out
1993		*/
1994		public void testAllowCoreThreadTimeOut_true() throws Exception {
1995	<	long coreThreadTimeOut = SHORT_DELAY_MS;
1995	>	long keepAliveTime = timeoutMillis();
1996		final ThreadPoolExecutor p =
1997		new ThreadPoolExecutor(2, 10,
1998	<	coreThreadTimeOut, MILLISECONDS,
1998	>	keepAliveTime, MILLISECONDS,
1999		new ArrayBlockingQueue<Runnable>(10));
2000		final CountDownLatch threadStarted = new CountDownLatch(1);
2001		try {
#	Line 1914 | Line 2006 | public class ThreadPoolExecutorTest exte
2006		assertEquals(1, p.getPoolSize());
2007		}});
2008		await(threadStarted);
2009	<	delay(coreThreadTimeOut);
2009	>	delay(keepAliveTime);
2010		long startTime = System.nanoTime();
2011		while (p.getPoolSize() > 0
2012		&& millisElapsedSince(startTime) < LONG_DELAY_MS)
#	Line 1930 | Line 2022 | public class ThreadPoolExecutorTest exte
2022		* allowCoreThreadTimeOut(false) causes idle threads not to time out
2023		*/
2024		public void testAllowCoreThreadTimeOut_false() throws Exception {
2025	<	long coreThreadTimeOut = SHORT_DELAY_MS;
2025	>	long keepAliveTime = timeoutMillis();
2026		final ThreadPoolExecutor p =
2027		new ThreadPoolExecutor(2, 10,
2028	<	coreThreadTimeOut, MILLISECONDS,
2028	>	keepAliveTime, MILLISECONDS,
2029		new ArrayBlockingQueue<Runnable>(10));
2030		final CountDownLatch threadStarted = new CountDownLatch(1);
2031		try {
#	Line 1943 | Line 2035 | public class ThreadPoolExecutorTest exte
2035		threadStarted.countDown();
2036		assertTrue(p.getPoolSize() >= 1);
2037		}});
2038	<	delay(2 * coreThreadTimeOut);
2038	>	delay(2 * keepAliveTime);
2039		assertTrue(p.getPoolSize() >= 1);
2040		} finally {
2041		joinPool(p);
#	Line 1962 | Line 2054 | public class ThreadPoolExecutorTest exte
2054		done.countDown();
2055		}};
2056		final ThreadPoolExecutor p =
2057	<	new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS,
2057	>	new ThreadPoolExecutor(1, 30,
2058	>	60, SECONDS,
2059		new ArrayBlockingQueue(30));
2060		try {
2061		for (int i = 0; i < nTasks; ++i) {
#	Line 1981 | Line 2074 | public class ThreadPoolExecutorTest exte
2074		}
2075		}
2076
2077	+	/**
2078	+	* get(cancelled task) throws CancellationException
2079	+	*/
2080	+	public void testGet_cancelled() throws Exception {
2081	+	final ExecutorService e =
2082	+	new ThreadPoolExecutor(1, 1,
2083	+	LONG_DELAY_MS, MILLISECONDS,
2084	+	new LinkedBlockingQueue<Runnable>());
2085	+	try {
2086	+	final CountDownLatch blockerStarted = new CountDownLatch(1);
2087	+	final CountDownLatch done = new CountDownLatch(1);
2088	+	final List<Future<?>> futures = new ArrayList<>();
2089	+	for (int i = 0; i < 2; i++) {
2090	+	Runnable r = new CheckedRunnable() { public void realRun()
2091	+	throws Throwable {
2092	+	blockerStarted.countDown();
2093	+	assertTrue(done.await(2 * LONG_DELAY_MS, MILLISECONDS));
2094	+	}};
2095	+	futures.add(e.submit(r));
2096	+	}
2097	+	assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2098	+	for (Future<?> future : futures) future.cancel(false);
2099	+	for (Future<?> future : futures) {
2100	+	try {
2101	+	future.get();
2102	+	shouldThrow();
2103	+	} catch (CancellationException success) {}
2104	+	try {
2105	+	future.get(LONG_DELAY_MS, MILLISECONDS);
2106	+	shouldThrow();
2107	+	} catch (CancellationException success) {}
2108	+	assertTrue(future.isCancelled());
2109	+	assertTrue(future.isDone());
2110	+	}
2111	+	done.countDown();
2112	+	} finally {
2113	+	joinPool(e);
2114	+	}
2115	+	}
2116	+
2117		}

Diff Legend

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