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.88 by jsr166, Tue Oct 6 00:41:47 2015 UTC vs.
Revision 1.99 by jsr166, Mon May 29 22:44:27 2017 UTC

#	Line 10 | Line 10 | import static java.util.concurrent.TimeU
10		import static java.util.concurrent.TimeUnit.SECONDS;
11
12		import java.util.ArrayList;
13	+	import java.util.Collection;
14	+	import java.util.Collections;
15		import java.util.List;
16		import java.util.concurrent.ArrayBlockingQueue;
17		import java.util.concurrent.BlockingQueue;
#	Line 17 | Line 19 | import java.util.concurrent.Callable;
19		import java.util.concurrent.CancellationException;
20		import java.util.concurrent.CountDownLatch;
21		import java.util.concurrent.ExecutionException;
20	–	import java.util.concurrent.Executors;
22		import java.util.concurrent.ExecutorService;
23		import java.util.concurrent.Future;
24		import java.util.concurrent.FutureTask;
#	Line 239 | Line 240 | public class ThreadPoolExecutorSubclassT
240		final Runnable task = new CheckedRunnable() {
241		public void realRun() { done.countDown(); }};
242		p.execute(task);
243	<	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
243	>	await(done);
244		}
245		}
246
#	Line 248 | Line 249 | public class ThreadPoolExecutorSubclassT
249		* thread becomes active
250		*/
251		public void testGetActiveCount() throws InterruptedException {
252	+	final CountDownLatch done = new CountDownLatch(1);
253		final ThreadPoolExecutor p =
254		new CustomTPE(2, 2,
255		LONG_DELAY_MS, MILLISECONDS,
256		new ArrayBlockingQueue<Runnable>(10));
257	<	try (PoolCleaner cleaner = cleaner(p)) {
257	>	try (PoolCleaner cleaner = cleaner(p, done)) {
258		final CountDownLatch threadStarted = new CountDownLatch(1);
257	–	final CountDownLatch done = new CountDownLatch(1);
259		assertEquals(0, p.getActiveCount());
260		p.execute(new CheckedRunnable() {
261		public void realRun() throws InterruptedException {
262		threadStarted.countDown();
263		assertEquals(1, p.getActiveCount());
264	<	done.await();
264	>	await(done);
265		}});
266	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
266	>	await(threadStarted);
267		assertEquals(1, p.getActiveCount());
267	–	done.countDown();
268		}
269		}
270
#	Line 334 | Line 334 | public class ThreadPoolExecutorSubclassT
334		public void realRun() throws InterruptedException {
335		threadStarted.countDown();
336		assertEquals(0, p.getCompletedTaskCount());
337	<	threadProceed.await();
337	>	await(threadProceed);
338		threadDone.countDown();
339		}});
340		await(threadStarted);
341		assertEquals(0, p.getCompletedTaskCount());
342		threadProceed.countDown();
343	<	threadDone.await();
343	>	await(threadDone);
344		long startTime = System.nanoTime();
345		while (p.getCompletedTaskCount() != 1) {
346		if (millisElapsedSince(startTime) > LONG_DELAY_MS)
#	Line 488 | Line 488 | public class ThreadPoolExecutorSubclassT
488		p.execute(new CheckedRunnable() {
489		public void realRun() throws InterruptedException {
490		threadsStarted.countDown();
491	<	done.await();
491	>	await(done);
492		assertEquals(THREADS, p.getLargestPoolSize());
493		}});
494	<	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
494	>	await(threadsStarted);
495		assertEquals(THREADS, p.getLargestPoolSize());
496		}
497		assertEquals(THREADS, p.getLargestPoolSize());
#	Line 532 | Line 532 | public class ThreadPoolExecutorSubclassT
532		public void realRun() throws InterruptedException {
533		threadStarted.countDown();
534		assertEquals(1, p.getPoolSize());
535	<	done.await();
535	>	await(done);
536		}});
537	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
537	>	await(threadStarted);
538		assertEquals(1, p.getPoolSize());
539		}
540		}
#	Line 556 | Line 556 | public class ThreadPoolExecutorSubclassT
556		p.execute(new CheckedRunnable() {
557		public void realRun() throws InterruptedException {
558		threadStarted.countDown();
559	<	done.await();
559	>	await(done);
560		}});
561	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
561	>	await(threadStarted);
562		assertEquals(1, p.getTaskCount());
563		assertEquals(0, p.getCompletedTaskCount());
564		for (int i = 0; i < TASKS; i++) {
#	Line 567 | Line 567 | public class ThreadPoolExecutorSubclassT
567		public void realRun() throws InterruptedException {
568		threadStarted.countDown();
569		assertEquals(1 + TASKS, p.getTaskCount());
570	<	done.await();
570	>	await(done);
571		}});
572		}
573		assertEquals(1 + TASKS, p.getTaskCount());
#	Line 608 | Line 608 | public class ThreadPoolExecutorSubclassT
608		public void realRun() throws InterruptedException {
609		assertFalse(p.isTerminating());
610		threadStarted.countDown();
611	<	done.await();
611	>	await(done);
612		}});
613	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
613	>	await(threadStarted);
614		assertFalse(p.isTerminating());
615		done.countDown();
616		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 636 | Line 636 | public class ThreadPoolExecutorSubclassT
636		public void realRun() throws InterruptedException {
637		assertFalse(p.isTerminating());
638		threadStarted.countDown();
639	<	done.await();
639	>	await(done);
640		}});
641	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
641	>	await(threadStarted);
642		assertFalse(p.isTerminating());
643		done.countDown();
644		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 652 | Line 652 | public class ThreadPoolExecutorSubclassT
652		* getQueue returns the work queue, which contains queued tasks
653		*/
654		public void testGetQueue() throws InterruptedException {
655	<	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
655	>	final CountDownLatch done = new CountDownLatch(1);
656	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
657		final ThreadPoolExecutor p =
658		new CustomTPE(1, 1,
659		LONG_DELAY_MS, MILLISECONDS,
660		q);
661	<	try (PoolCleaner cleaner = cleaner(p)) {
661	>	try (PoolCleaner cleaner = cleaner(p, done)) {
662		final CountDownLatch threadStarted = new CountDownLatch(1);
662	–	final CountDownLatch done = new CountDownLatch(1);
663		FutureTask[] tasks = new FutureTask[5];
664		for (int i = 0; i < tasks.length; i++) {
665	<	Callable task = new CheckedCallable<Boolean>() {
665	>	Callable<Boolean> task = new CheckedCallable<Boolean>() {
666		public Boolean realCall() throws InterruptedException {
667		threadStarted.countDown();
668		assertSame(q, p.getQueue());
669	<	done.await();
669	>	await(done);
670		return Boolean.TRUE;
671		}};
672		tasks[i] = new FutureTask(task);
673		p.execute(tasks[i]);
674		}
675	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
675	>	await(threadStarted);
676		assertSame(q, p.getQueue());
677		assertFalse(q.contains(tasks[0]));
678		assertTrue(q.contains(tasks[tasks.length - 1]));
679		assertEquals(tasks.length - 1, q.size());
680	–	done.countDown();
680		}
681		}
682
#	Line 685 | Line 684 | public class ThreadPoolExecutorSubclassT
684		* remove(task) removes queued task, and fails to remove active task
685		*/
686		public void testRemove() throws InterruptedException {
687	<	BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
687	>	final CountDownLatch done = new CountDownLatch(1);
688	>	BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
689		final ThreadPoolExecutor p =
690		new CustomTPE(1, 1,
691		LONG_DELAY_MS, MILLISECONDS,
692		q);
693	<	try (PoolCleaner cleaner = cleaner(p)) {
693	>	try (PoolCleaner cleaner = cleaner(p, done)) {
694		Runnable[] tasks = new Runnable[6];
695		final CountDownLatch threadStarted = new CountDownLatch(1);
696	–	final CountDownLatch done = new CountDownLatch(1);
696		for (int i = 0; i < tasks.length; i++) {
697		tasks[i] = new CheckedRunnable() {
698		public void realRun() throws InterruptedException {
699		threadStarted.countDown();
700	<	done.await();
700	>	await(done);
701		}};
702		p.execute(tasks[i]);
703		}
704	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
704	>	await(threadStarted);
705		assertFalse(p.remove(tasks[0]));
706		assertTrue(q.contains(tasks[4]));
707		assertTrue(q.contains(tasks[3]));
#	Line 712 | Line 711 | public class ThreadPoolExecutorSubclassT
711		assertTrue(q.contains(tasks[3]));
712		assertTrue(p.remove(tasks[3]));
713		assertFalse(q.contains(tasks[3]));
715	–	done.countDown();
714		}
715		}
716
#	Line 722 | Line 720 | public class ThreadPoolExecutorSubclassT
720		public void testPurge() throws InterruptedException {
721		final CountDownLatch threadStarted = new CountDownLatch(1);
722		final CountDownLatch done = new CountDownLatch(1);
723	<	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
723	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
724		final ThreadPoolExecutor p =
725		new CustomTPE(1, 1,
726		LONG_DELAY_MS, MILLISECONDS,
#	Line 730 | Line 728 | public class ThreadPoolExecutorSubclassT
728		try (PoolCleaner cleaner = cleaner(p, done)) {
729		FutureTask[] tasks = new FutureTask[5];
730		for (int i = 0; i < tasks.length; i++) {
731	<	Callable task = new CheckedCallable<Boolean>() {
731	>	Callable<Boolean> task = new CheckedCallable<Boolean>() {
732		public Boolean realCall() throws InterruptedException {
733		threadStarted.countDown();
734	<	done.await();
734	>	await(done);
735		return Boolean.TRUE;
736		}};
737		tasks[i] = new FutureTask(task);
738		p.execute(tasks[i]);
739		}
740	<	assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
740	>	await(threadStarted);
741		assertEquals(tasks.length, p.getTaskCount());
742		assertEquals(tasks.length - 1, q.size());
743		assertEquals(1L, p.getActiveCount());
#	Line 777 | Line 775 | public class ThreadPoolExecutorSubclassT
775		}};
776		for (int i = 0; i < count; i++)
777		p.execute(waiter);
778	<	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
778	>	await(threadsStarted);
779		assertEquals(poolSize, p.getActiveCount());
780		assertEquals(0, p.getCompletedTaskCount());
781		final List<Runnable> queuedTasks;
#	Line 1136 | Line 1134 | public class ThreadPoolExecutorSubclassT
1134		* execute throws RejectedExecutionException if saturated.
1135		*/
1136		public void testSaturatedExecute() {
1137	+	final CountDownLatch done = new CountDownLatch(1);
1138		final ThreadPoolExecutor p =
1139		new CustomTPE(1, 1,
1140		LONG_DELAY_MS, MILLISECONDS,
1141		new ArrayBlockingQueue<Runnable>(1));
1142	<	try (PoolCleaner cleaner = cleaner(p)) {
1144	<	final CountDownLatch done = new CountDownLatch(1);
1142	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1143		Runnable task = new CheckedRunnable() {
1144		public void realRun() throws InterruptedException {
1145	<	done.await();
1145	>	await(done);
1146		}};
1147		for (int i = 0; i < 2; ++i)
1148		p.execute(task);
#	Line 1155 | Line 1153 | public class ThreadPoolExecutorSubclassT
1153		} catch (RejectedExecutionException success) {}
1154		assertTrue(p.getTaskCount() <= 2);
1155		}
1158	–	done.countDown();
1156		}
1157		}
1158
#	Line 1163 | Line 1160 | public class ThreadPoolExecutorSubclassT
1160		* executor using CallerRunsPolicy runs task if saturated.
1161		*/
1162		public void testSaturatedExecute2() {
1163	+	final CountDownLatch done = new CountDownLatch(1);
1164		final ThreadPoolExecutor p =
1165		new CustomTPE(1, 1,
1166		LONG_DELAY_MS, MILLISECONDS,
1167		new ArrayBlockingQueue<Runnable>(1),
1168		new CustomTPE.CallerRunsPolicy());
1169	<	try (PoolCleaner cleaner = cleaner(p)) {
1172	<	final CountDownLatch done = new CountDownLatch(1);
1169	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1170		Runnable blocker = new CheckedRunnable() {
1171		public void realRun() throws InterruptedException {
1172	<	done.await();
1172	>	await(done);
1173		}};
1174		p.execute(blocker);
1175		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
#	Line 1183 | Line 1180 | public class ThreadPoolExecutorSubclassT
1180		for (int i = 1; i < tasks.length; i++)
1181		assertTrue(tasks[i].done);
1182		assertFalse(tasks[0].done); // waiting in queue
1186	–	done.countDown();
1183		}
1184		}
1185
#	Line 1194 | Line 1190 | public class ThreadPoolExecutorSubclassT
1190		final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1191		for (int i = 0; i < tasks.length; ++i)
1192		tasks[i] = new TrackedNoOpRunnable();
1193	+	final CountDownLatch done = new CountDownLatch(1);
1194		final ThreadPoolExecutor p =
1195		new CustomTPE(1, 1,
1196		LONG_DELAY_MS, MILLISECONDS,
1197		new ArrayBlockingQueue<Runnable>(1),
1198		new CustomTPE.DiscardPolicy());
1199	<	try (PoolCleaner cleaner = cleaner(p)) {
1203	<	final CountDownLatch done = new CountDownLatch(1);
1199	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1200		p.execute(awaiter(done));
1201
1202		for (TrackedNoOpRunnable task : tasks)
1203		p.execute(task);
1204		for (int i = 1; i < tasks.length; i++)
1205		assertFalse(tasks[i].done);
1210	–	done.countDown();
1206		}
1207		for (int i = 1; i < tasks.length; i++)
1208		assertFalse(tasks[i].done);
#	Line 1227 | Line 1222 | public class ThreadPoolExecutorSubclassT
1222		LONG_DELAY_MS, MILLISECONDS,
1223		new ArrayBlockingQueue<Runnable>(1),
1224		new CustomTPE.DiscardOldestPolicy());
1225	<	try (PoolCleaner cleaner = cleaner(p)) {
1225	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1226		assertEquals(LatchAwaiter.NEW, r1.state);
1227		assertEquals(LatchAwaiter.NEW, r2.state);
1228		assertEquals(LatchAwaiter.NEW, r3.state);
#	Line 1237 | Line 1232 | public class ThreadPoolExecutorSubclassT
1232		p.execute(r3);
1233		assertFalse(p.getQueue().contains(r2));
1234		assertTrue(p.getQueue().contains(r3));
1240	–	done.countDown();
1235		}
1236		assertEquals(LatchAwaiter.DONE, r1.state);
1237		assertEquals(LatchAwaiter.NEW, r2.state);
#	Line 1472 | Line 1466 | public class ThreadPoolExecutorSubclassT
1466		}
1467
1468		/**
1469	<	* invokeAny(null) throws NPE
1469	>	* invokeAny(null) throws NullPointerException
1470		*/
1471		public void testInvokeAny1() throws Exception {
1472		final ExecutorService e =
#	Line 1488 | Line 1482 | public class ThreadPoolExecutorSubclassT
1482		}
1483
1484		/**
1485	<	* invokeAny(empty collection) throws IAE
1485	>	* invokeAny(empty collection) throws IllegalArgumentException
1486		*/
1487		public void testInvokeAny2() throws Exception {
1488		final ExecutorService e =
#	Line 1513 | Line 1507 | public class ThreadPoolExecutorSubclassT
1507		LONG_DELAY_MS, MILLISECONDS,
1508		new ArrayBlockingQueue<Runnable>(10));
1509		try (PoolCleaner cleaner = cleaner(e)) {
1510	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1510	>	List<Callable<String>> l = new ArrayList<>();
1511		l.add(latchAwaitingStringTask(latch));
1512		l.add(null);
1513		try {
#	Line 1533 | Line 1527 | public class ThreadPoolExecutorSubclassT
1527		LONG_DELAY_MS, MILLISECONDS,
1528		new ArrayBlockingQueue<Runnable>(10));
1529		try (PoolCleaner cleaner = cleaner(e)) {
1530	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1530	>	List<Callable<String>> l = new ArrayList<>();
1531		l.add(new NPETask());
1532		try {
1533		e.invokeAny(l);
#	Line 1553 | Line 1547 | public class ThreadPoolExecutorSubclassT
1547		LONG_DELAY_MS, MILLISECONDS,
1548		new ArrayBlockingQueue<Runnable>(10));
1549		try (PoolCleaner cleaner = cleaner(e)) {
1550	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1550	>	List<Callable<String>> l = new ArrayList<>();
1551		l.add(new StringTask());
1552		l.add(new StringTask());
1553		String result = e.invokeAny(l);
#	Line 1578 | Line 1572 | public class ThreadPoolExecutorSubclassT
1572		}
1573
1574		/**
1575	<	* invokeAll(empty collection) returns empty collection
1575	>	* invokeAll(empty collection) returns empty list
1576		*/
1577		public void testInvokeAll2() throws Exception {
1578		final ExecutorService e =
1579		new CustomTPE(2, 2,
1580		LONG_DELAY_MS, MILLISECONDS,
1581		new ArrayBlockingQueue<Runnable>(10));
1582	+	final Collection<Callable<String>> emptyCollection
1583	+	= Collections.emptyList();
1584		try (PoolCleaner cleaner = cleaner(e)) {
1585	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1585	>	List<Future<String>> r = e.invokeAll(emptyCollection);
1586		assertTrue(r.isEmpty());
1587		}
1588		}
#	Line 1600 | Line 1596 | public class ThreadPoolExecutorSubclassT
1596		LONG_DELAY_MS, MILLISECONDS,
1597		new ArrayBlockingQueue<Runnable>(10));
1598		try (PoolCleaner cleaner = cleaner(e)) {
1599	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1599	>	List<Callable<String>> l = new ArrayList<>();
1600		l.add(new StringTask());
1601		l.add(null);
1602		try {
#	Line 1619 | Line 1615 | public class ThreadPoolExecutorSubclassT
1615		LONG_DELAY_MS, MILLISECONDS,
1616		new ArrayBlockingQueue<Runnable>(10));
1617		try (PoolCleaner cleaner = cleaner(e)) {
1618	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1618	>	List<Callable<String>> l = new ArrayList<>();
1619		l.add(new NPETask());
1620		List<Future<String>> futures = e.invokeAll(l);
1621		assertEquals(1, futures.size());
#	Line 1641 | Line 1637 | public class ThreadPoolExecutorSubclassT
1637		LONG_DELAY_MS, MILLISECONDS,
1638		new ArrayBlockingQueue<Runnable>(10));
1639		try (PoolCleaner cleaner = cleaner(e)) {
1640	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1640	>	List<Callable<String>> l = new ArrayList<>();
1641		l.add(new StringTask());
1642		l.add(new StringTask());
1643		List<Future<String>> futures = e.invokeAll(l);
#	Line 1661 | Line 1657 | public class ThreadPoolExecutorSubclassT
1657		new ArrayBlockingQueue<Runnable>(10));
1658		try (PoolCleaner cleaner = cleaner(e)) {
1659		try {
1660	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1660	>	e.invokeAny(null, randomTimeout(), randomTimeUnit());
1661		shouldThrow();
1662		} catch (NullPointerException success) {}
1663		}
#	Line 1676 | Line 1672 | public class ThreadPoolExecutorSubclassT
1672		LONG_DELAY_MS, MILLISECONDS,
1673		new ArrayBlockingQueue<Runnable>(10));
1674		try (PoolCleaner cleaner = cleaner(e)) {
1675	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1675	>	List<Callable<String>> l = new ArrayList<>();
1676		l.add(new StringTask());
1677		try {
1678	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1678	>	e.invokeAny(l, randomTimeout(), null);
1679		shouldThrow();
1680		} catch (NullPointerException success) {}
1681		}
1682		}
1683
1684		/**
1685	<	* timed invokeAny(empty collection) throws IAE
1685	>	* timed invokeAny(empty collection) throws IllegalArgumentException
1686		*/
1687		public void testTimedInvokeAny2() throws Exception {
1688		final ExecutorService e =
1689		new CustomTPE(2, 2,
1690		LONG_DELAY_MS, MILLISECONDS,
1691		new ArrayBlockingQueue<Runnable>(10));
1692	+	final Collection<Callable<String>> emptyCollection
1693	+	= Collections.emptyList();
1694		try (PoolCleaner cleaner = cleaner(e)) {
1695		try {
1696	<	e.invokeAny(new ArrayList<Callable<String>>(),
1699	<	MEDIUM_DELAY_MS, MILLISECONDS);
1696	>	e.invokeAny(emptyCollection, randomTimeout(), randomTimeUnit());
1697		shouldThrow();
1698		} catch (IllegalArgumentException success) {}
1699		}
#	Line 1712 | Line 1709 | public class ThreadPoolExecutorSubclassT
1709		LONG_DELAY_MS, MILLISECONDS,
1710		new ArrayBlockingQueue<Runnable>(10));
1711		try (PoolCleaner cleaner = cleaner(e)) {
1712	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1712	>	List<Callable<String>> l = new ArrayList<>();
1713		l.add(latchAwaitingStringTask(latch));
1714		l.add(null);
1715		try {
1716	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1716	>	e.invokeAny(l, randomTimeout(), MILLISECONDS);
1717		shouldThrow();
1718		} catch (NullPointerException success) {}
1719		latch.countDown();
#	Line 1732 | Line 1729 | public class ThreadPoolExecutorSubclassT
1729		LONG_DELAY_MS, MILLISECONDS,
1730		new ArrayBlockingQueue<Runnable>(10));
1731		try (PoolCleaner cleaner = cleaner(e)) {
1732	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1732	>	long startTime = System.nanoTime();
1733	>	List<Callable<String>> l = new ArrayList<>();
1734		l.add(new NPETask());
1735		try {
1736	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1736	>	e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1737		shouldThrow();
1738		} catch (ExecutionException success) {
1739		assertTrue(success.getCause() instanceof NullPointerException);
1740		}
1741	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1742		}
1743		}
1744
#	Line 1752 | Line 1751 | public class ThreadPoolExecutorSubclassT
1751		LONG_DELAY_MS, MILLISECONDS,
1752		new ArrayBlockingQueue<Runnable>(10));
1753		try (PoolCleaner cleaner = cleaner(e)) {
1754	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1754	>	long startTime = System.nanoTime();
1755	>	List<Callable<String>> l = new ArrayList<>();
1756		l.add(new StringTask());
1757		l.add(new StringTask());
1758	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1758	>	String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1759		assertSame(TEST_STRING, result);
1760	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1761		}
1762		}
1763
#	Line 1770 | Line 1771 | public class ThreadPoolExecutorSubclassT
1771		new ArrayBlockingQueue<Runnable>(10));
1772		try (PoolCleaner cleaner = cleaner(e)) {
1773		try {
1774	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1774	>	e.invokeAll(null, randomTimeout(), randomTimeUnit());
1775		shouldThrow();
1776		} catch (NullPointerException success) {}
1777		}
#	Line 1785 | Line 1786 | public class ThreadPoolExecutorSubclassT
1786		LONG_DELAY_MS, MILLISECONDS,
1787		new ArrayBlockingQueue<Runnable>(10));
1788		try (PoolCleaner cleaner = cleaner(e)) {
1789	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1789	>	List<Callable<String>> l = new ArrayList<>();
1790		l.add(new StringTask());
1791		try {
1792	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1792	>	e.invokeAll(l, randomTimeout(), null);
1793		shouldThrow();
1794		} catch (NullPointerException success) {}
1795		}
1796		}
1797
1798		/**
1799	<	* timed invokeAll(empty collection) returns empty collection
1799	>	* timed invokeAll(empty collection) returns empty list
1800		*/
1801		public void testTimedInvokeAll2() throws Exception {
1802		final ExecutorService e =
1803		new CustomTPE(2, 2,
1804		LONG_DELAY_MS, MILLISECONDS,
1805		new ArrayBlockingQueue<Runnable>(10));
1806	+	final Collection<Callable<String>> emptyCollection
1807	+	= Collections.emptyList();
1808		try (PoolCleaner cleaner = cleaner(e)) {
1809	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1810	<	MEDIUM_DELAY_MS, MILLISECONDS);
1809	>	List<Future<String>> r =
1810	>	e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1811		assertTrue(r.isEmpty());
1812		}
1813		}
#	Line 1818 | Line 1821 | public class ThreadPoolExecutorSubclassT
1821		LONG_DELAY_MS, MILLISECONDS,
1822		new ArrayBlockingQueue<Runnable>(10));
1823		try (PoolCleaner cleaner = cleaner(e)) {
1824	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1824	>	List<Callable<String>> l = new ArrayList<>();
1825		l.add(new StringTask());
1826		l.add(null);
1827		try {
1828	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1828	>	e.invokeAll(l, randomTimeout(), randomTimeUnit());
1829		shouldThrow();
1830		} catch (NullPointerException success) {}
1831		}
#	Line 1837 | Line 1840 | public class ThreadPoolExecutorSubclassT
1840		LONG_DELAY_MS, MILLISECONDS,
1841		new ArrayBlockingQueue<Runnable>(10));
1842		try (PoolCleaner cleaner = cleaner(e)) {
1843	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1843	>	List<Callable<String>> l = new ArrayList<>();
1844		l.add(new NPETask());
1845		List<Future<String>> futures =
1846		e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1860 | Line 1863 | public class ThreadPoolExecutorSubclassT
1863		LONG_DELAY_MS, MILLISECONDS,
1864		new ArrayBlockingQueue<Runnable>(10));
1865		try (PoolCleaner cleaner = cleaner(e)) {
1866	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1866	>	List<Callable<String>> l = new ArrayList<>();
1867		l.add(new StringTask());
1868		l.add(new StringTask());
1869		List<Future<String>> futures =
#	Line 1875 | Line 1878 | public class ThreadPoolExecutorSubclassT
1878		* timed invokeAll(c) cancels tasks not completed by timeout
1879		*/
1880		public void testTimedInvokeAll6() throws Exception {
1881	<	final ExecutorService e =
1882	<	new CustomTPE(2, 2,
1883	<	LONG_DELAY_MS, MILLISECONDS,
1884	<	new ArrayBlockingQueue<Runnable>(10));
1885	<	try (PoolCleaner cleaner = cleaner(e)) {
1886	<	for (long timeout = timeoutMillis();;) {
1881	>	for (long timeout = timeoutMillis();;) {
1882	>	final CountDownLatch done = new CountDownLatch(1);
1883	>	final Callable<String> waiter = new CheckedCallable<String>() {
1884	>	public String realCall() {
1885	>	try { done.await(LONG_DELAY_MS, MILLISECONDS); }
1886	>	catch (InterruptedException ok) {}
1887	>	return "1"; }};
1888	>	final ExecutorService p =
1889	>	new CustomTPE(2, 2,
1890	>	LONG_DELAY_MS, MILLISECONDS,
1891	>	new ArrayBlockingQueue<Runnable>(10));
1892	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1893		List<Callable<String>> tasks = new ArrayList<>();
1894		tasks.add(new StringTask("0"));
1895	<	tasks.add(Executors.callable(new LongPossiblyInterruptedRunnable(), TEST_STRING));
1895	>	tasks.add(waiter);
1896		tasks.add(new StringTask("2"));
1897		long startTime = System.nanoTime();
1898		List<Future<String>> futures =
1899	<	e.invokeAll(tasks, timeout, MILLISECONDS);
1899	>	p.invokeAll(tasks, timeout, MILLISECONDS);
1900		assertEquals(tasks.size(), futures.size());
1901		assertTrue(millisElapsedSince(startTime) >= timeout);
1902		for (Future future : futures)
#	Line 1924 | Line 1933 | public class ThreadPoolExecutorSubclassT
1933		public void realRun() {
1934		done.countDown();
1935		}});
1936	<	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1936	>	await(done);
1937		}
1938		}
1939
#	Line 1996 | Line 2005 | public class ThreadPoolExecutorSubclassT
2005		* (in part, a test of CustomTPE itself)
2006		*/
2007		public void testGet_cancelled() throws Exception {
2008	+	final CountDownLatch done = new CountDownLatch(1);
2009		final ExecutorService e =
2010		new CustomTPE(1, 1,
2011		LONG_DELAY_MS, MILLISECONDS,
2012		new LinkedBlockingQueue<Runnable>());
2013	<	try (PoolCleaner cleaner = cleaner(e)) {
2013	>	try (PoolCleaner cleaner = cleaner(e, done)) {
2014		final CountDownLatch blockerStarted = new CountDownLatch(1);
2005	–	final CountDownLatch done = new CountDownLatch(1);
2015		final List<Future<?>> futures = new ArrayList<>();
2016		for (int i = 0; i < 2; i++) {
2017		Runnable r = new CheckedRunnable() { public void realRun()
#	Line 2012 | Line 2021 | public class ThreadPoolExecutorSubclassT
2021		}};
2022		futures.add(e.submit(r));
2023		}
2024	<	assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2024	>	await(blockerStarted);
2025		for (Future<?> future : futures) future.cancel(false);
2026		for (Future<?> future : futures) {
2027		try {
#	Line 2026 | Line 2035 | public class ThreadPoolExecutorSubclassT
2035		assertTrue(future.isCancelled());
2036		assertTrue(future.isDone());
2037		}
2029	–	done.countDown();
2038		}
2039		}
2040

Diff Legend

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