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.80 by jsr166, Sun Oct 4 06:39:13 2015 UTC vs.
Revision 1.92 by jsr166, Tue Oct 6 05:56:01 2015 UTC

#	Line 248 | Line 248 | public class ThreadPoolExecutorSubclassT
248		* thread becomes active
249		*/
250		public void testGetActiveCount() throws InterruptedException {
251	+	final CountDownLatch done = new CountDownLatch(1);
252		final ThreadPoolExecutor p =
253		new CustomTPE(2, 2,
254		LONG_DELAY_MS, MILLISECONDS,
255		new ArrayBlockingQueue<Runnable>(10));
256	<	try (PoolCleaner cleaner = cleaner(p)) {
256	>	try (PoolCleaner cleaner = cleaner(p, done)) {
257		final CountDownLatch threadStarted = new CountDownLatch(1);
257	–	final CountDownLatch done = new CountDownLatch(1);
258		assertEquals(0, p.getActiveCount());
259		p.execute(new CheckedRunnable() {
260		public void realRun() throws InterruptedException {
261		threadStarted.countDown();
262		assertEquals(1, p.getActiveCount());
263	<	done.await();
263	>	await(done);
264		}});
265	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
265	>	await(threadStarted);
266		assertEquals(1, p.getActiveCount());
267	–	done.countDown();
267		}
268		}
269
#	Line 476 | Line 475 | public class ThreadPoolExecutorSubclassT
475		*/
476		public void testGetLargestPoolSize() throws InterruptedException {
477		final int THREADS = 3;
478	+	final CountDownLatch done = new CountDownLatch(1);
479		final ThreadPoolExecutor p =
480		new CustomTPE(THREADS, THREADS,
481		LONG_DELAY_MS, MILLISECONDS,
482		new ArrayBlockingQueue<Runnable>(10));
483	<	try (PoolCleaner cleaner = cleaner(p)) {
484	<	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
485	<	final CountDownLatch done = new CountDownLatch(1);
483	>	try (PoolCleaner cleaner = cleaner(p, done)) {
484		assertEquals(0, p.getLargestPoolSize());
485	+	final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
486		for (int i = 0; i < THREADS; i++)
487		p.execute(new CheckedRunnable() {
488		public void realRun() throws InterruptedException {
489		threadsStarted.countDown();
490	<	done.await();
490	>	await(done);
491		assertEquals(THREADS, p.getLargestPoolSize());
492		}});
493	<	assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
493	>	await(threadsStarted);
494		assertEquals(THREADS, p.getLargestPoolSize());
496	–	done.countDown();   // release pool
495		}
496		assertEquals(THREADS, p.getLargestPoolSize());
497		}
#	Line 521 | Line 519 | public class ThreadPoolExecutorSubclassT
519		* become active
520		*/
521		public void testGetPoolSize() throws InterruptedException {
522	+	final CountDownLatch done = new CountDownLatch(1);
523		final ThreadPoolExecutor p =
524		new CustomTPE(1, 1,
525		LONG_DELAY_MS, MILLISECONDS,
526		new ArrayBlockingQueue<Runnable>(10));
527	<	try (PoolCleaner cleaner = cleaner(p)) {
529	<	final CountDownLatch threadStarted = new CountDownLatch(1);
530	<	final CountDownLatch done = new CountDownLatch(1);
527	>	try (PoolCleaner cleaner = cleaner(p, done)) {
528		assertEquals(0, p.getPoolSize());
529	+	final CountDownLatch threadStarted = new CountDownLatch(1);
530		p.execute(new CheckedRunnable() {
531		public void realRun() throws InterruptedException {
532		threadStarted.countDown();
533		assertEquals(1, p.getPoolSize());
534	<	done.await();
534	>	await(done);
535		}});
536	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
536	>	await(threadStarted);
537		assertEquals(1, p.getPoolSize());
540	–	done.countDown();   // release pool
538		}
539		}
540
#	Line 545 | Line 542 | public class ThreadPoolExecutorSubclassT
542		* getTaskCount increases, but doesn't overestimate, when tasks submitted
543		*/
544		public void testGetTaskCount() throws InterruptedException {
545	+	final int TASKS = 3;
546	+	final CountDownLatch done = new CountDownLatch(1);
547		final ThreadPoolExecutor p =
548		new CustomTPE(1, 1,
549		LONG_DELAY_MS, MILLISECONDS,
550		new ArrayBlockingQueue<Runnable>(10));
551	<	try (PoolCleaner cleaner = cleaner(p)) {
551	>	try (PoolCleaner cleaner = cleaner(p, done)) {
552		final CountDownLatch threadStarted = new CountDownLatch(1);
554	–	final CountDownLatch done = new CountDownLatch(1);
553		assertEquals(0, p.getTaskCount());
554	+	assertEquals(0, p.getCompletedTaskCount());
555		p.execute(new CheckedRunnable() {
556		public void realRun() throws InterruptedException {
557		threadStarted.countDown();
558	<	assertEquals(1, p.getTaskCount());
560	<	done.await();
558	>	await(done);
559		}});
560	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
560	>	await(threadStarted);
561		assertEquals(1, p.getTaskCount());
562	<	done.countDown();
562	>	assertEquals(0, p.getCompletedTaskCount());
563	>	for (int i = 0; i < TASKS; i++) {
564	>	assertEquals(1 + i, p.getTaskCount());
565	>	p.execute(new CheckedRunnable() {
566	>	public void realRun() throws InterruptedException {
567	>	threadStarted.countDown();
568	>	assertEquals(1 + TASKS, p.getTaskCount());
569	>	await(done);
570	>	}});
571	>	}
572	>	assertEquals(1 + TASKS, p.getTaskCount());
573	>	assertEquals(0, p.getCompletedTaskCount());
574		}
575	+	assertEquals(1 + TASKS, p.getTaskCount());
576	+	assertEquals(1 + TASKS, p.getCompletedTaskCount());
577		}
578
579		/**
#	Line 596 | Line 607 | public class ThreadPoolExecutorSubclassT
607		public void realRun() throws InterruptedException {
608		assertFalse(p.isTerminating());
609		threadStarted.countDown();
610	<	done.await();
610	>	await(done);
611		}});
612	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
612	>	await(threadStarted);
613		assertFalse(p.isTerminating());
614		done.countDown();
615		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 624 | Line 635 | public class ThreadPoolExecutorSubclassT
635		public void realRun() throws InterruptedException {
636		assertFalse(p.isTerminating());
637		threadStarted.countDown();
638	<	done.await();
638	>	await(done);
639		}});
640	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
640	>	await(threadStarted);
641		assertFalse(p.isTerminating());
642		done.countDown();
643		try { p.shutdown(); } catch (SecurityException ok) { return; }
#	Line 640 | Line 651 | public class ThreadPoolExecutorSubclassT
651		* getQueue returns the work queue, which contains queued tasks
652		*/
653		public void testGetQueue() throws InterruptedException {
654	+	final CountDownLatch done = new CountDownLatch(1);
655		final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
656		final ThreadPoolExecutor p =
657		new CustomTPE(1, 1,
658		LONG_DELAY_MS, MILLISECONDS,
659		q);
660	<	try (PoolCleaner cleaner = cleaner(p)) {
660	>	try (PoolCleaner cleaner = cleaner(p, done)) {
661		final CountDownLatch threadStarted = new CountDownLatch(1);
650	–	final CountDownLatch done = new CountDownLatch(1);
662		FutureTask[] tasks = new FutureTask[5];
663		for (int i = 0; i < tasks.length; i++) {
664		Callable task = new CheckedCallable<Boolean>() {
665		public Boolean realCall() throws InterruptedException {
666		threadStarted.countDown();
667		assertSame(q, p.getQueue());
668	<	done.await();
668	>	await(done);
669		return Boolean.TRUE;
670		}};
671		tasks[i] = new FutureTask(task);
672		p.execute(tasks[i]);
673		}
674	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
674	>	await(threadStarted);
675		assertSame(q, p.getQueue());
676		assertFalse(q.contains(tasks[0]));
677		assertTrue(q.contains(tasks[tasks.length - 1]));
678		assertEquals(tasks.length - 1, q.size());
668	–	done.countDown();
679		}
680		}
681
#	Line 673 | Line 683 | public class ThreadPoolExecutorSubclassT
683		* remove(task) removes queued task, and fails to remove active task
684		*/
685		public void testRemove() throws InterruptedException {
686	+	final CountDownLatch done = new CountDownLatch(1);
687		BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
688		final ThreadPoolExecutor p =
689		new CustomTPE(1, 1,
690		LONG_DELAY_MS, MILLISECONDS,
691		q);
692	<	try (PoolCleaner cleaner = cleaner(p)) {
692	>	try (PoolCleaner cleaner = cleaner(p, done)) {
693		Runnable[] tasks = new Runnable[6];
694		final CountDownLatch threadStarted = new CountDownLatch(1);
684	–	final CountDownLatch done = new CountDownLatch(1);
695		for (int i = 0; i < tasks.length; i++) {
696		tasks[i] = new CheckedRunnable() {
697		public void realRun() throws InterruptedException {
698		threadStarted.countDown();
699	<	done.await();
699	>	await(done);
700		}};
701		p.execute(tasks[i]);
702		}
703	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
703	>	await(threadStarted);
704		assertFalse(p.remove(tasks[0]));
705		assertTrue(q.contains(tasks[4]));
706		assertTrue(q.contains(tasks[3]));
#	Line 700 | Line 710 | public class ThreadPoolExecutorSubclassT
710		assertTrue(q.contains(tasks[3]));
711		assertTrue(p.remove(tasks[3]));
712		assertFalse(q.contains(tasks[3]));
703	–	done.countDown();
713		}
714		}
715
#	Line 715 | Line 724 | public class ThreadPoolExecutorSubclassT
724		new CustomTPE(1, 1,
725		LONG_DELAY_MS, MILLISECONDS,
726		q);
727	<	try (PoolCleaner cleaner = cleaner(p)) {
727	>	try (PoolCleaner cleaner = cleaner(p, done)) {
728		FutureTask[] tasks = new FutureTask[5];
729		for (int i = 0; i < tasks.length; i++) {
730		Callable task = new CheckedCallable<Boolean>() {
731		public Boolean realCall() throws InterruptedException {
732		threadStarted.countDown();
733	<	done.await();
733	>	await(done);
734		return Boolean.TRUE;
735		}};
736		tasks[i] = new FutureTask(task);
737		p.execute(tasks[i]);
738		}
739	<	assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
739	>	await(threadStarted);
740		assertEquals(tasks.length, p.getTaskCount());
741		assertEquals(tasks.length - 1, q.size());
742		assertEquals(1L, p.getActiveCount());
#	Line 740 | Line 749 | public class ThreadPoolExecutorSubclassT
749		p.purge();         // Nothing to do
750		assertEquals(tasks.length - 3, q.size());
751		assertEquals(tasks.length - 2, p.getTaskCount());
743	–	done.countDown();
752		}
753		}
754
#	Line 753 | Line 761 | public class ThreadPoolExecutorSubclassT
761		final int count = 5;
762		final AtomicInteger ran = new AtomicInteger(0);
763		final ThreadPoolExecutor p =
764	<	new CustomTPE(poolSize, poolSize, LONG_DELAY_MS, MILLISECONDS,
764	>	new CustomTPE(poolSize, poolSize,
765	>	LONG_DELAY_MS, MILLISECONDS,
766		new ArrayBlockingQueue<Runnable>(10));
767	<	CountDownLatch threadsStarted = new CountDownLatch(poolSize);
767	>	final CountDownLatch threadsStarted = new CountDownLatch(poolSize);
768		Runnable waiter = new CheckedRunnable() { public void realRun() {
769		threadsStarted.countDown();
770		try {
#	Line 765 | Line 774 | public class ThreadPoolExecutorSubclassT
774		}};
775		for (int i = 0; i < count; i++)
776		p.execute(waiter);
777	<	assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
777	>	await(threadsStarted);
778		assertEquals(poolSize, p.getActiveCount());
779		assertEquals(0, p.getCompletedTaskCount());
780		final List<Runnable> queuedTasks;
#	Line 1124 | Line 1133 | public class ThreadPoolExecutorSubclassT
1133		* execute throws RejectedExecutionException if saturated.
1134		*/
1135		public void testSaturatedExecute() {
1136	+	final CountDownLatch done = new CountDownLatch(1);
1137		final ThreadPoolExecutor p =
1138		new CustomTPE(1, 1,
1139		LONG_DELAY_MS, MILLISECONDS,
1140		new ArrayBlockingQueue<Runnable>(1));
1141	<	try (PoolCleaner cleaner = cleaner(p)) {
1132	<	final CountDownLatch done = new CountDownLatch(1);
1141	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1142		Runnable task = new CheckedRunnable() {
1143		public void realRun() throws InterruptedException {
1144	<	done.await();
1144	>	await(done);
1145		}};
1146		for (int i = 0; i < 2; ++i)
1147		p.execute(task);
#	Line 1143 | Line 1152 | public class ThreadPoolExecutorSubclassT
1152		} catch (RejectedExecutionException success) {}
1153		assertTrue(p.getTaskCount() <= 2);
1154		}
1146	–	done.countDown();
1155		}
1156		}
1157
#	Line 1151 | Line 1159 | public class ThreadPoolExecutorSubclassT
1159		* executor using CallerRunsPolicy runs task if saturated.
1160		*/
1161		public void testSaturatedExecute2() {
1162	+	final CountDownLatch done = new CountDownLatch(1);
1163		final ThreadPoolExecutor p =
1164		new CustomTPE(1, 1,
1165		LONG_DELAY_MS, MILLISECONDS,
1166		new ArrayBlockingQueue<Runnable>(1),
1167		new CustomTPE.CallerRunsPolicy());
1168	<	try (PoolCleaner cleaner = cleaner(p)) {
1160	<	final CountDownLatch done = new CountDownLatch(1);
1168	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1169		Runnable blocker = new CheckedRunnable() {
1170		public void realRun() throws InterruptedException {
1171	<	done.await();
1171	>	await(done);
1172		}};
1173		p.execute(blocker);
1174		TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
#	Line 1171 | Line 1179 | public class ThreadPoolExecutorSubclassT
1179		for (int i = 1; i < tasks.length; i++)
1180		assertTrue(tasks[i].done);
1181		assertFalse(tasks[0].done); // waiting in queue
1174	–	done.countDown();
1182		}
1183		}
1184
#	Line 1182 | Line 1189 | public class ThreadPoolExecutorSubclassT
1189		final TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5];
1190		for (int i = 0; i < tasks.length; ++i)
1191		tasks[i] = new TrackedNoOpRunnable();
1192	+	final CountDownLatch done = new CountDownLatch(1);
1193		final ThreadPoolExecutor p =
1194		new CustomTPE(1, 1,
1195		LONG_DELAY_MS, MILLISECONDS,
1196		new ArrayBlockingQueue<Runnable>(1),
1197		new CustomTPE.DiscardPolicy());
1198	<	try (PoolCleaner cleaner = cleaner(p)) {
1191	<	final CountDownLatch done = new CountDownLatch(1);
1198	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1199		p.execute(awaiter(done));
1200
1201		for (TrackedNoOpRunnable task : tasks)
1202		p.execute(task);
1203		for (int i = 1; i < tasks.length; i++)
1204		assertFalse(tasks[i].done);
1198	–	done.countDown();
1205		}
1206		for (int i = 1; i < tasks.length; i++)
1207		assertFalse(tasks[i].done);
#	Line 1215 | Line 1221 | public class ThreadPoolExecutorSubclassT
1221		LONG_DELAY_MS, MILLISECONDS,
1222		new ArrayBlockingQueue<Runnable>(1),
1223		new CustomTPE.DiscardOldestPolicy());
1224	<	try (PoolCleaner cleaner = cleaner(p)) {
1224	>	try (PoolCleaner cleaner = cleaner(p, done)) {
1225		assertEquals(LatchAwaiter.NEW, r1.state);
1226		assertEquals(LatchAwaiter.NEW, r2.state);
1227		assertEquals(LatchAwaiter.NEW, r3.state);
#	Line 1225 | Line 1231 | public class ThreadPoolExecutorSubclassT
1231		p.execute(r3);
1232		assertFalse(p.getQueue().contains(r2));
1233		assertTrue(p.getQueue().contains(r3));
1228	–	done.countDown();
1234		}
1235		assertEquals(LatchAwaiter.DONE, r1.state);
1236		assertEquals(LatchAwaiter.NEW, r2.state);
#	Line 1322 | Line 1327 | public class ThreadPoolExecutorSubclassT
1327		*/
1328		public void testCorePoolSizeIllegalArgumentException() {
1329		final ThreadPoolExecutor p =
1330	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1331	<	try {
1332	<	p.setCorePoolSize(-1);
1333	<	shouldThrow();
1334	<	} catch (IllegalArgumentException success) {
1335	<	} finally {
1336	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1330	>	new CustomTPE(1, 2,
1331	>	LONG_DELAY_MS, MILLISECONDS,
1332	>	new ArrayBlockingQueue<Runnable>(10));
1333	>	try (PoolCleaner cleaner = cleaner(p)) {
1334	>	try {
1335	>	p.setCorePoolSize(-1);
1336	>	shouldThrow();
1337	>	} catch (IllegalArgumentException success) {}
1338		}
1333	–	joinPool(p);
1339		}
1340
1341		/**
#	Line 1339 | Line 1344 | public class ThreadPoolExecutorSubclassT
1344		*/
1345		public void testMaximumPoolSizeIllegalArgumentException() {
1346		final ThreadPoolExecutor p =
1347	<	new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1348	<	try {
1349	<	p.setMaximumPoolSize(1);
1350	<	shouldThrow();
1351	<	} catch (IllegalArgumentException success) {
1352	<	} finally {
1353	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1347	>	new CustomTPE(2, 3,
1348	>	LONG_DELAY_MS, MILLISECONDS,
1349	>	new ArrayBlockingQueue<Runnable>(10));
1350	>	try (PoolCleaner cleaner = cleaner(p)) {
1351	>	try {
1352	>	p.setMaximumPoolSize(1);
1353	>	shouldThrow();
1354	>	} catch (IllegalArgumentException success) {}
1355		}
1350	–	joinPool(p);
1356		}
1357
1358		/**
#	Line 1356 | Line 1361 | public class ThreadPoolExecutorSubclassT
1361		*/
1362		public void testMaximumPoolSizeIllegalArgumentException2() {
1363		final ThreadPoolExecutor p =
1364	<	new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1365	<	try {
1366	<	p.setMaximumPoolSize(-1);
1367	<	shouldThrow();
1368	<	} catch (IllegalArgumentException success) {
1369	<	} finally {
1370	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1364	>	new CustomTPE(2, 3,
1365	>	LONG_DELAY_MS,
1366	>	MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1367	>	try (PoolCleaner cleaner = cleaner(p)) {
1368	>	try {
1369	>	p.setMaximumPoolSize(-1);
1370	>	shouldThrow();
1371	>	} catch (IllegalArgumentException success) {}
1372		}
1367	–	joinPool(p);
1373		}
1374
1375		/**
#	Line 1373 | Line 1378 | public class ThreadPoolExecutorSubclassT
1378		*/
1379		public void testKeepAliveTimeIllegalArgumentException() {
1380		final ThreadPoolExecutor p =
1381	<	new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1382	<
1383	<	try {
1384	<	p.setKeepAliveTime(-1,MILLISECONDS);
1385	<	shouldThrow();
1386	<	} catch (IllegalArgumentException success) {
1387	<	} finally {
1388	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1381	>	new CustomTPE(2, 3,
1382	>	LONG_DELAY_MS, MILLISECONDS,
1383	>	new ArrayBlockingQueue<Runnable>(10));
1384	>	try (PoolCleaner cleaner = cleaner(p)) {
1385	>	try {
1386	>	p.setKeepAliveTime(-1, MILLISECONDS);
1387	>	shouldThrow();
1388	>	} catch (IllegalArgumentException success) {}
1389		}
1385	–	joinPool(p);
1390		}
1391
1392		/**
#	Line 1390 | Line 1394 | public class ThreadPoolExecutorSubclassT
1394		*/
1395		public void testTerminated() {
1396		CustomTPE p = new CustomTPE();
1397	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1398	<	assertTrue(p.terminatedCalled());
1399	<	joinPool(p);
1397	>	try (PoolCleaner cleaner = cleaner(p)) {
1398	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1399	>	assertTrue(p.terminatedCalled());
1400	>	assertTrue(p.isShutdown());
1401	>	}
1402		}
1403
1404		/**
#	Line 1400 | Line 1406 | public class ThreadPoolExecutorSubclassT
1406		*/
1407		public void testBeforeAfter() throws InterruptedException {
1408		CustomTPE p = new CustomTPE();
1409	<	try {
1409	>	try (PoolCleaner cleaner = cleaner(p)) {
1410		final CountDownLatch done = new CountDownLatch(1);
1411		p.execute(new CheckedRunnable() {
1412		public void realRun() {
#	Line 1410 | Line 1416 | public class ThreadPoolExecutorSubclassT
1416		assertEquals(0, done.getCount());
1417		assertTrue(p.afterCalled());
1418		assertTrue(p.beforeCalled());
1413	–	try { p.shutdown(); } catch (SecurityException ok) { return; }
1414	–	} finally {
1415	–	joinPool(p);
1419		}
1420		}
1421
#	Line 1424 | Line 1427 | public class ThreadPoolExecutorSubclassT
1427		new CustomTPE(2, 2,
1428		LONG_DELAY_MS, MILLISECONDS,
1429		new ArrayBlockingQueue<Runnable>(10));
1430	<	try {
1430	>	try (PoolCleaner cleaner = cleaner(e)) {
1431		Future<String> future = e.submit(new StringTask());
1432		String result = future.get();
1433		assertSame(TEST_STRING, result);
1431	–	} finally {
1432	–	joinPool(e);
1434		}
1435		}
1436
#	Line 1441 | Line 1442 | public class ThreadPoolExecutorSubclassT
1442		new CustomTPE(2, 2,
1443		LONG_DELAY_MS, MILLISECONDS,
1444		new ArrayBlockingQueue<Runnable>(10));
1445	<	try {
1445	>	try (PoolCleaner cleaner = cleaner(e)) {
1446		Future<?> future = e.submit(new NoOpRunnable());
1447		future.get();
1448		assertTrue(future.isDone());
1448	–	} finally {
1449	–	joinPool(e);
1449		}
1450		}
1451
#	Line 1458 | Line 1457 | public class ThreadPoolExecutorSubclassT
1457		new CustomTPE(2, 2,
1458		LONG_DELAY_MS, MILLISECONDS,
1459		new ArrayBlockingQueue<Runnable>(10));
1460	<	try {
1460	>	try (PoolCleaner cleaner = cleaner(e)) {
1461		Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1462		String result = future.get();
1463		assertSame(TEST_STRING, result);
1465	–	} finally {
1466	–	joinPool(e);
1464		}
1465		}
1466
#	Line 1475 | Line 1472 | public class ThreadPoolExecutorSubclassT
1472		new CustomTPE(2, 2,
1473		LONG_DELAY_MS, MILLISECONDS,
1474		new ArrayBlockingQueue<Runnable>(10));
1475	<	try {
1476	<	e.invokeAny(null);
1477	<	shouldThrow();
1478	<	} catch (NullPointerException success) {
1479	<	} finally {
1483	<	joinPool(e);
1475	>	try (PoolCleaner cleaner = cleaner(e)) {
1476	>	try {
1477	>	e.invokeAny(null);
1478	>	shouldThrow();
1479	>	} catch (NullPointerException success) {}
1480		}
1481		}
1482
#	Line 1492 | Line 1488 | public class ThreadPoolExecutorSubclassT
1488		new CustomTPE(2, 2,
1489		LONG_DELAY_MS, MILLISECONDS,
1490		new ArrayBlockingQueue<Runnable>(10));
1491	<	try {
1492	<	e.invokeAny(new ArrayList<Callable<String>>());
1493	<	shouldThrow();
1494	<	} catch (IllegalArgumentException success) {
1495	<	} finally {
1500	<	joinPool(e);
1491	>	try (PoolCleaner cleaner = cleaner(e)) {
1492	>	try {
1493	>	e.invokeAny(new ArrayList<Callable<String>>());
1494	>	shouldThrow();
1495	>	} catch (IllegalArgumentException success) {}
1496		}
1497		}
1498
#	Line 1510 | Line 1505 | public class ThreadPoolExecutorSubclassT
1505		new CustomTPE(2, 2,
1506		LONG_DELAY_MS, MILLISECONDS,
1507		new ArrayBlockingQueue<Runnable>(10));
1508	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1509	<	l.add(latchAwaitingStringTask(latch));
1510	<	l.add(null);
1511	<	try {
1512	<	e.invokeAny(l);
1513	<	shouldThrow();
1514	<	} catch (NullPointerException success) {
1515	<	} finally {
1508	>	try (PoolCleaner cleaner = cleaner(e)) {
1509	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1510	>	l.add(latchAwaitingStringTask(latch));
1511	>	l.add(null);
1512	>	try {
1513	>	e.invokeAny(l);
1514	>	shouldThrow();
1515	>	} catch (NullPointerException success) {}
1516		latch.countDown();
1522	–	joinPool(e);
1517		}
1518		}
1519
#	Line 1531 | Line 1525 | public class ThreadPoolExecutorSubclassT
1525		new CustomTPE(2, 2,
1526		LONG_DELAY_MS, MILLISECONDS,
1527		new ArrayBlockingQueue<Runnable>(10));
1528	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1529	<	l.add(new NPETask());
1530	<	try {
1531	<	e.invokeAny(l);
1532	<	shouldThrow();
1533	<	} catch (ExecutionException success) {
1534	<	assertTrue(success.getCause() instanceof NullPointerException);
1535	<	} finally {
1536	<	joinPool(e);
1528	>	try (PoolCleaner cleaner = cleaner(e)) {
1529	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1530	>	l.add(new NPETask());
1531	>	try {
1532	>	e.invokeAny(l);
1533	>	shouldThrow();
1534	>	} catch (ExecutionException success) {
1535	>	assertTrue(success.getCause() instanceof NullPointerException);
1536	>	}
1537		}
1538		}
1539
#	Line 1551 | Line 1545 | public class ThreadPoolExecutorSubclassT
1545		new CustomTPE(2, 2,
1546		LONG_DELAY_MS, MILLISECONDS,
1547		new ArrayBlockingQueue<Runnable>(10));
1548	<	try {
1548	>	try (PoolCleaner cleaner = cleaner(e)) {
1549		List<Callable<String>> l = new ArrayList<Callable<String>>();
1550		l.add(new StringTask());
1551		l.add(new StringTask());
1552		String result = e.invokeAny(l);
1553		assertSame(TEST_STRING, result);
1560	–	} finally {
1561	–	joinPool(e);
1554		}
1555		}
1556
#	Line 1570 | Line 1562 | public class ThreadPoolExecutorSubclassT
1562		new CustomTPE(2, 2,
1563		LONG_DELAY_MS, MILLISECONDS,
1564		new ArrayBlockingQueue<Runnable>(10));
1565	<	try {
1566	<	e.invokeAll(null);
1567	<	shouldThrow();
1568	<	} catch (NullPointerException success) {
1569	<	} finally {
1578	<	joinPool(e);
1565	>	try (PoolCleaner cleaner = cleaner(e)) {
1566	>	try {
1567	>	e.invokeAll(null);
1568	>	shouldThrow();
1569	>	} catch (NullPointerException success) {}
1570		}
1571		}
1572
#	Line 1587 | Line 1578 | public class ThreadPoolExecutorSubclassT
1578		new CustomTPE(2, 2,
1579		LONG_DELAY_MS, MILLISECONDS,
1580		new ArrayBlockingQueue<Runnable>(10));
1581	<	try {
1581	>	try (PoolCleaner cleaner = cleaner(e)) {
1582		List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1583		assertTrue(r.isEmpty());
1593	–	} finally {
1594	–	joinPool(e);
1584		}
1585		}
1586
#	Line 1603 | Line 1592 | public class ThreadPoolExecutorSubclassT
1592		new CustomTPE(2, 2,
1593		LONG_DELAY_MS, MILLISECONDS,
1594		new ArrayBlockingQueue<Runnable>(10));
1595	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1596	<	l.add(new StringTask());
1597	<	l.add(null);
1598	<	try {
1599	<	e.invokeAll(l);
1600	<	shouldThrow();
1601	<	} catch (NullPointerException success) {
1602	<	} finally {
1614	<	joinPool(e);
1595	>	try (PoolCleaner cleaner = cleaner(e)) {
1596	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1597	>	l.add(new StringTask());
1598	>	l.add(null);
1599	>	try {
1600	>	e.invokeAll(l);
1601	>	shouldThrow();
1602	>	} catch (NullPointerException success) {}
1603		}
1604		}
1605
#	Line 1623 | Line 1611 | public class ThreadPoolExecutorSubclassT
1611		new CustomTPE(2, 2,
1612		LONG_DELAY_MS, MILLISECONDS,
1613		new ArrayBlockingQueue<Runnable>(10));
1614	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1615	<	l.add(new NPETask());
1616	<	List<Future<String>> futures = e.invokeAll(l);
1617	<	assertEquals(1, futures.size());
1618	<	try {
1619	<	futures.get(0).get();
1620	<	shouldThrow();
1621	<	} catch (ExecutionException success) {
1622	<	assertTrue(success.getCause() instanceof NullPointerException);
1623	<	} finally {
1624	<	joinPool(e);
1614	>	try (PoolCleaner cleaner = cleaner(e)) {
1615	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1616	>	l.add(new NPETask());
1617	>	List<Future<String>> futures = e.invokeAll(l);
1618	>	assertEquals(1, futures.size());
1619	>	try {
1620	>	futures.get(0).get();
1621	>	shouldThrow();
1622	>	} catch (ExecutionException success) {
1623	>	assertTrue(success.getCause() instanceof NullPointerException);
1624	>	}
1625		}
1626		}
1627
#	Line 1645 | Line 1633 | public class ThreadPoolExecutorSubclassT
1633		new CustomTPE(2, 2,
1634		LONG_DELAY_MS, MILLISECONDS,
1635		new ArrayBlockingQueue<Runnable>(10));
1636	<	try {
1636	>	try (PoolCleaner cleaner = cleaner(e)) {
1637		List<Callable<String>> l = new ArrayList<Callable<String>>();
1638		l.add(new StringTask());
1639		l.add(new StringTask());
#	Line 1653 | Line 1641 | public class ThreadPoolExecutorSubclassT
1641		assertEquals(2, futures.size());
1642		for (Future<String> future : futures)
1643		assertSame(TEST_STRING, future.get());
1656	–	} finally {
1657	–	joinPool(e);
1644		}
1645		}
1646
#	Line 1666 | Line 1652 | public class ThreadPoolExecutorSubclassT
1652		new CustomTPE(2, 2,
1653		LONG_DELAY_MS, MILLISECONDS,
1654		new ArrayBlockingQueue<Runnable>(10));
1655	<	try {
1656	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1657	<	shouldThrow();
1658	<	} catch (NullPointerException success) {
1659	<	} finally {
1674	<	joinPool(e);
1655	>	try (PoolCleaner cleaner = cleaner(e)) {
1656	>	try {
1657	>	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1658	>	shouldThrow();
1659	>	} catch (NullPointerException success) {}
1660		}
1661		}
1662
#	Line 1683 | Line 1668 | public class ThreadPoolExecutorSubclassT
1668		new CustomTPE(2, 2,
1669		LONG_DELAY_MS, MILLISECONDS,
1670		new ArrayBlockingQueue<Runnable>(10));
1671	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1672	<	l.add(new StringTask());
1673	<	try {
1674	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1675	<	shouldThrow();
1676	<	} catch (NullPointerException success) {
1677	<	} finally {
1693	<	joinPool(e);
1671	>	try (PoolCleaner cleaner = cleaner(e)) {
1672	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1673	>	l.add(new StringTask());
1674	>	try {
1675	>	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1676	>	shouldThrow();
1677	>	} catch (NullPointerException success) {}
1678		}
1679		}
1680
#	Line 1702 | Line 1686 | public class ThreadPoolExecutorSubclassT
1686		new CustomTPE(2, 2,
1687		LONG_DELAY_MS, MILLISECONDS,
1688		new ArrayBlockingQueue<Runnable>(10));
1689	<	try {
1690	<	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1691	<	shouldThrow();
1692	<	} catch (IllegalArgumentException success) {
1693	<	} finally {
1694	<	joinPool(e);
1689	>	try (PoolCleaner cleaner = cleaner(e)) {
1690	>	try {
1691	>	e.invokeAny(new ArrayList<Callable<String>>(),
1692	>	MEDIUM_DELAY_MS, MILLISECONDS);
1693	>	shouldThrow();
1694	>	} catch (IllegalArgumentException success) {}
1695		}
1696		}
1697
#	Line 1720 | Line 1704 | public class ThreadPoolExecutorSubclassT
1704		new CustomTPE(2, 2,
1705		LONG_DELAY_MS, MILLISECONDS,
1706		new ArrayBlockingQueue<Runnable>(10));
1707	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1708	<	l.add(latchAwaitingStringTask(latch));
1709	<	l.add(null);
1710	<	try {
1711	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1712	<	shouldThrow();
1713	<	} catch (NullPointerException success) {
1714	<	} finally {
1707	>	try (PoolCleaner cleaner = cleaner(e)) {
1708	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1709	>	l.add(latchAwaitingStringTask(latch));
1710	>	l.add(null);
1711	>	try {
1712	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1713	>	shouldThrow();
1714	>	} catch (NullPointerException success) {}
1715		latch.countDown();
1732	–	joinPool(e);
1716		}
1717		}
1718
#	Line 1741 | Line 1724 | public class ThreadPoolExecutorSubclassT
1724		new CustomTPE(2, 2,
1725		LONG_DELAY_MS, MILLISECONDS,
1726		new ArrayBlockingQueue<Runnable>(10));
1727	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1728	<	l.add(new NPETask());
1729	<	try {
1730	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1731	<	shouldThrow();
1732	<	} catch (ExecutionException success) {
1733	<	assertTrue(success.getCause() instanceof NullPointerException);
1734	<	} finally {
1735	<	joinPool(e);
1727	>	try (PoolCleaner cleaner = cleaner(e)) {
1728	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1729	>	l.add(new NPETask());
1730	>	try {
1731	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1732	>	shouldThrow();
1733	>	} catch (ExecutionException success) {
1734	>	assertTrue(success.getCause() instanceof NullPointerException);
1735	>	}
1736		}
1737		}
1738
#	Line 1761 | Line 1744 | public class ThreadPoolExecutorSubclassT
1744		new CustomTPE(2, 2,
1745		LONG_DELAY_MS, MILLISECONDS,
1746		new ArrayBlockingQueue<Runnable>(10));
1747	<	try {
1747	>	try (PoolCleaner cleaner = cleaner(e)) {
1748		List<Callable<String>> l = new ArrayList<Callable<String>>();
1749		l.add(new StringTask());
1750		l.add(new StringTask());
1751		String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1752		assertSame(TEST_STRING, result);
1770	–	} finally {
1771	–	joinPool(e);
1753		}
1754		}
1755
#	Line 1780 | Line 1761 | public class ThreadPoolExecutorSubclassT
1761		new CustomTPE(2, 2,
1762		LONG_DELAY_MS, MILLISECONDS,
1763		new ArrayBlockingQueue<Runnable>(10));
1764	<	try {
1765	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1766	<	shouldThrow();
1767	<	} catch (NullPointerException success) {
1768	<	} finally {
1788	<	joinPool(e);
1764	>	try (PoolCleaner cleaner = cleaner(e)) {
1765	>	try {
1766	>	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1767	>	shouldThrow();
1768	>	} catch (NullPointerException success) {}
1769		}
1770		}
1771
#	Line 1797 | Line 1777 | public class ThreadPoolExecutorSubclassT
1777		new CustomTPE(2, 2,
1778		LONG_DELAY_MS, MILLISECONDS,
1779		new ArrayBlockingQueue<Runnable>(10));
1780	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1781	<	l.add(new StringTask());
1782	<	try {
1783	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1784	<	shouldThrow();
1785	<	} catch (NullPointerException success) {
1786	<	} finally {
1807	<	joinPool(e);
1780	>	try (PoolCleaner cleaner = cleaner(e)) {
1781	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1782	>	l.add(new StringTask());
1783	>	try {
1784	>	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1785	>	shouldThrow();
1786	>	} catch (NullPointerException success) {}
1787		}
1788		}
1789
#	Line 1816 | Line 1795 | public class ThreadPoolExecutorSubclassT
1795		new CustomTPE(2, 2,
1796		LONG_DELAY_MS, MILLISECONDS,
1797		new ArrayBlockingQueue<Runnable>(10));
1798	<	try {
1799	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1798	>	try (PoolCleaner cleaner = cleaner(e)) {
1799	>	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1800	>	MEDIUM_DELAY_MS, MILLISECONDS);
1801		assertTrue(r.isEmpty());
1822	–	} finally {
1823	–	joinPool(e);
1802		}
1803		}
1804
#	Line 1832 | Line 1810 | public class ThreadPoolExecutorSubclassT
1810		new CustomTPE(2, 2,
1811		LONG_DELAY_MS, MILLISECONDS,
1812		new ArrayBlockingQueue<Runnable>(10));
1813	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1814	<	l.add(new StringTask());
1815	<	l.add(null);
1816	<	try {
1817	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1818	<	shouldThrow();
1819	<	} catch (NullPointerException success) {
1820	<	} finally {
1843	<	joinPool(e);
1813	>	try (PoolCleaner cleaner = cleaner(e)) {
1814	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1815	>	l.add(new StringTask());
1816	>	l.add(null);
1817	>	try {
1818	>	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1819	>	shouldThrow();
1820	>	} catch (NullPointerException success) {}
1821		}
1822		}
1823
#	Line 1852 | Line 1829 | public class ThreadPoolExecutorSubclassT
1829		new CustomTPE(2, 2,
1830		LONG_DELAY_MS, MILLISECONDS,
1831		new ArrayBlockingQueue<Runnable>(10));
1832	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1833	<	l.add(new NPETask());
1834	<	List<Future<String>> futures =
1835	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1836	<	assertEquals(1, futures.size());
1837	<	try {
1838	<	futures.get(0).get();
1839	<	shouldThrow();
1840	<	} catch (ExecutionException success) {
1841	<	assertTrue(success.getCause() instanceof NullPointerException);
1842	<	} finally {
1843	<	joinPool(e);
1832	>	try (PoolCleaner cleaner = cleaner(e)) {
1833	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1834	>	l.add(new NPETask());
1835	>	List<Future<String>> futures =
1836	>	e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
1837	>	assertEquals(1, futures.size());
1838	>	try {
1839	>	futures.get(0).get();
1840	>	shouldThrow();
1841	>	} catch (ExecutionException success) {
1842	>	assertTrue(success.getCause() instanceof NullPointerException);
1843	>	}
1844		}
1845		}
1846
#	Line 1875 | Line 1852 | public class ThreadPoolExecutorSubclassT
1852		new CustomTPE(2, 2,
1853		LONG_DELAY_MS, MILLISECONDS,
1854		new ArrayBlockingQueue<Runnable>(10));
1855	<	try {
1855	>	try (PoolCleaner cleaner = cleaner(e)) {
1856		List<Callable<String>> l = new ArrayList<Callable<String>>();
1857		l.add(new StringTask());
1858		l.add(new StringTask());
#	Line 1884 | Line 1861 | public class ThreadPoolExecutorSubclassT
1861		assertEquals(2, futures.size());
1862		for (Future<String> future : futures)
1863		assertSame(TEST_STRING, future.get());
1887	–	} finally {
1888	–	joinPool(e);
1864		}
1865		}
1866
#	Line 1897 | Line 1872 | public class ThreadPoolExecutorSubclassT
1872		new CustomTPE(2, 2,
1873		LONG_DELAY_MS, MILLISECONDS,
1874		new ArrayBlockingQueue<Runnable>(10));
1875	<	try {
1875	>	try (PoolCleaner cleaner = cleaner(e)) {
1876		for (long timeout = timeoutMillis();;) {
1877		List<Callable<String>> tasks = new ArrayList<>();
1878		tasks.add(new StringTask("0"));
#	Line 1921 | Line 1896 | public class ThreadPoolExecutorSubclassT
1896		fail("expected exactly one task to be cancelled");
1897		}
1898		}
1924	–	} finally {
1925	–	joinPool(e);
1899		}
1900		}
1901
#	Line 1936 | Line 1909 | public class ThreadPoolExecutorSubclassT
1909		LONG_DELAY_MS, MILLISECONDS,
1910		new LinkedBlockingQueue<Runnable>(),
1911		new FailingThreadFactory());
1912	<	try {
1912	>	try (PoolCleaner cleaner = cleaner(e)) {
1913		final int TASKS = 100;
1914		final CountDownLatch done = new CountDownLatch(TASKS);
1915		for (int k = 0; k < TASKS; ++k)
#	Line 1945 | Line 1918 | public class ThreadPoolExecutorSubclassT
1918		done.countDown();
1919		}});
1920		assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1948	–	} finally {
1949	–	joinPool(e);
1921		}
1922		}
1923
#	Line 1958 | Line 1929 | public class ThreadPoolExecutorSubclassT
1929		new CustomTPE(2, 2,
1930		1000, MILLISECONDS,
1931		new ArrayBlockingQueue<Runnable>(10));
1932	<	assertFalse(p.allowsCoreThreadTimeOut());
1933	<	joinPool(p);
1932	>	try (PoolCleaner cleaner = cleaner(p)) {
1933	>	assertFalse(p.allowsCoreThreadTimeOut());
1934	>	}
1935		}
1936
1937		/**
#	Line 1971 | Line 1943 | public class ThreadPoolExecutorSubclassT
1943		new CustomTPE(2, 10,
1944		keepAliveTime, MILLISECONDS,
1945		new ArrayBlockingQueue<Runnable>(10));
1946	<	final CountDownLatch threadStarted = new CountDownLatch(1);
1947	<	try {
1946	>	try (PoolCleaner cleaner = cleaner(p)) {
1947	>	final CountDownLatch threadStarted = new CountDownLatch(1);
1948		p.allowCoreThreadTimeOut(true);
1949		p.execute(new CheckedRunnable() {
1950		public void realRun() {
#	Line 1987 | Line 1959 | public class ThreadPoolExecutorSubclassT
1959		Thread.yield();
1960		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1961		assertEquals(0, p.getPoolSize());
1990	–	} finally {
1991	–	joinPool(p);
1962		}
1963		}
1964
#	Line 2001 | Line 1971 | public class ThreadPoolExecutorSubclassT
1971		new CustomTPE(2, 10,
1972		keepAliveTime, MILLISECONDS,
1973		new ArrayBlockingQueue<Runnable>(10));
1974	<	final CountDownLatch threadStarted = new CountDownLatch(1);
1975	<	try {
1974	>	try (PoolCleaner cleaner = cleaner(p)) {
1975	>	final CountDownLatch threadStarted = new CountDownLatch(1);
1976		p.allowCoreThreadTimeOut(false);
1977		p.execute(new CheckedRunnable() {
1978		public void realRun() throws InterruptedException {
#	Line 2011 | Line 1981 | public class ThreadPoolExecutorSubclassT
1981		}});
1982		delay(2 * keepAliveTime);
1983		assertTrue(p.getPoolSize() >= 1);
2014	–	} finally {
2015	–	joinPool(p);
1984		}
1985		}
1986
#	Line 2021 | Line 1989 | public class ThreadPoolExecutorSubclassT
1989		* (in part, a test of CustomTPE itself)
1990		*/
1991		public void testGet_cancelled() throws Exception {
1992	+	final CountDownLatch done = new CountDownLatch(1);
1993		final ExecutorService e =
1994		new CustomTPE(1, 1,
1995		LONG_DELAY_MS, MILLISECONDS,
1996		new LinkedBlockingQueue<Runnable>());
1997	<	try {
1997	>	try (PoolCleaner cleaner = cleaner(e, done)) {
1998		final CountDownLatch blockerStarted = new CountDownLatch(1);
2030	–	final CountDownLatch done = new CountDownLatch(1);
1999		final List<Future<?>> futures = new ArrayList<>();
2000		for (int i = 0; i < 2; i++) {
2001		Runnable r = new CheckedRunnable() { public void realRun()
#	Line 2037 | Line 2005 | public class ThreadPoolExecutorSubclassT
2005		}};
2006		futures.add(e.submit(r));
2007		}
2008	<	assertTrue(blockerStarted.await(LONG_DELAY_MS, MILLISECONDS));
2008	>	await(blockerStarted);
2009		for (Future<?> future : futures) future.cancel(false);
2010		for (Future<?> future : futures) {
2011		try {
#	Line 2051 | Line 2019 | public class ThreadPoolExecutorSubclassT
2019		assertTrue(future.isCancelled());
2020		assertTrue(future.isDone());
2021		}
2054	–	done.countDown();
2055	–	} finally {
2056	–	joinPool(e);
2022		}
2023		}
2024

Diff Legend

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