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.82 by jsr166, Sun Oct 4 07:23:20 2015 UTC

#	Line 753 | Line 753 | public class ThreadPoolExecutorSubclassT
753		final int count = 5;
754		final AtomicInteger ran = new AtomicInteger(0);
755		final ThreadPoolExecutor p =
756	<	new CustomTPE(poolSize, poolSize, LONG_DELAY_MS, MILLISECONDS,
756	>	new CustomTPE(poolSize, poolSize,
757	>	LONG_DELAY_MS, MILLISECONDS,
758		new ArrayBlockingQueue<Runnable>(10));
759		CountDownLatch threadsStarted = new CountDownLatch(poolSize);
760		Runnable waiter = new CheckedRunnable() { public void realRun() {
#	Line 1322 | Line 1323 | public class ThreadPoolExecutorSubclassT
1323		*/
1324		public void testCorePoolSizeIllegalArgumentException() {
1325		final ThreadPoolExecutor p =
1326	<	new CustomTPE(1,2,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1327	<	try {
1328	<	p.setCorePoolSize(-1);
1329	<	shouldThrow();
1330	<	} catch (IllegalArgumentException success) {
1331	<	} finally {
1332	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1326	>	new CustomTPE(1, 2,
1327	>	LONG_DELAY_MS, MILLISECONDS,
1328	>	new ArrayBlockingQueue<Runnable>(10));
1329	>	try (PoolCleaner cleaner = cleaner(p)) {
1330	>	try {
1331	>	p.setCorePoolSize(-1);
1332	>	shouldThrow();
1333	>	} catch (IllegalArgumentException success) {}
1334		}
1333	–	joinPool(p);
1335		}
1336
1337		/**
#	Line 1339 | Line 1340 | public class ThreadPoolExecutorSubclassT
1340		*/
1341		public void testMaximumPoolSizeIllegalArgumentException() {
1342		final ThreadPoolExecutor p =
1343	<	new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1344	<	try {
1345	<	p.setMaximumPoolSize(1);
1346	<	shouldThrow();
1347	<	} catch (IllegalArgumentException success) {
1348	<	} finally {
1349	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1343	>	new CustomTPE(2, 3,
1344	>	LONG_DELAY_MS, MILLISECONDS,
1345	>	new ArrayBlockingQueue<Runnable>(10));
1346	>	try (PoolCleaner cleaner = cleaner(p)) {
1347	>	try {
1348	>	p.setMaximumPoolSize(1);
1349	>	shouldThrow();
1350	>	} catch (IllegalArgumentException success) {}
1351		}
1350	–	joinPool(p);
1352		}
1353
1354		/**
#	Line 1356 | Line 1357 | public class ThreadPoolExecutorSubclassT
1357		*/
1358		public void testMaximumPoolSizeIllegalArgumentException2() {
1359		final ThreadPoolExecutor p =
1360	<	new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1361	<	try {
1362	<	p.setMaximumPoolSize(-1);
1363	<	shouldThrow();
1364	<	} catch (IllegalArgumentException success) {
1365	<	} finally {
1366	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1360	>	new CustomTPE(2, 3,
1361	>	LONG_DELAY_MS,
1362	>	MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1363	>	try (PoolCleaner cleaner = cleaner(p)) {
1364	>	try {
1365	>	p.setMaximumPoolSize(-1);
1366	>	shouldThrow();
1367	>	} catch (IllegalArgumentException success) {}
1368		}
1367	–	joinPool(p);
1369		}
1370
1371		/**
#	Line 1373 | Line 1374 | public class ThreadPoolExecutorSubclassT
1374		*/
1375		public void testKeepAliveTimeIllegalArgumentException() {
1376		final ThreadPoolExecutor p =
1377	<	new CustomTPE(2,3,LONG_DELAY_MS, MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
1378	<
1379	<	try {
1380	<	p.setKeepAliveTime(-1,MILLISECONDS);
1381	<	shouldThrow();
1382	<	} catch (IllegalArgumentException success) {
1383	<	} finally {
1384	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1377	>	new CustomTPE(2, 3,
1378	>	LONG_DELAY_MS, MILLISECONDS,
1379	>	new ArrayBlockingQueue<Runnable>(10));
1380	>	try (PoolCleaner cleaner = cleaner(p)) {
1381	>	try {
1382	>	p.setKeepAliveTime(-1, MILLISECONDS);
1383	>	shouldThrow();
1384	>	} catch (IllegalArgumentException success) {}
1385		}
1385	–	joinPool(p);
1386		}
1387
1388		/**
#	Line 1390 | Line 1390 | public class ThreadPoolExecutorSubclassT
1390		*/
1391		public void testTerminated() {
1392		CustomTPE p = new CustomTPE();
1393	<	try { p.shutdown(); } catch (SecurityException ok) { return; }
1394	<	assertTrue(p.terminatedCalled());
1395	<	joinPool(p);
1393	>	try (PoolCleaner cleaner = cleaner(p)) {
1394	>	try { p.shutdown(); } catch (SecurityException ok) { return; }
1395	>	assertTrue(p.terminatedCalled());
1396	>	assertTrue(p.isShutdown());
1397	>	}
1398		}
1399
1400		/**
#	Line 1400 | Line 1402 | public class ThreadPoolExecutorSubclassT
1402		*/
1403		public void testBeforeAfter() throws InterruptedException {
1404		CustomTPE p = new CustomTPE();
1405	<	try {
1405	>	try (PoolCleaner cleaner = cleaner(p)) {
1406		final CountDownLatch done = new CountDownLatch(1);
1407		p.execute(new CheckedRunnable() {
1408		public void realRun() {
#	Line 1410 | Line 1412 | public class ThreadPoolExecutorSubclassT
1412		assertEquals(0, done.getCount());
1413		assertTrue(p.afterCalled());
1414		assertTrue(p.beforeCalled());
1413	–	try { p.shutdown(); } catch (SecurityException ok) { return; }
1414	–	} finally {
1415	–	joinPool(p);
1415		}
1416		}
1417
#	Line 1424 | Line 1423 | public class ThreadPoolExecutorSubclassT
1423		new CustomTPE(2, 2,
1424		LONG_DELAY_MS, MILLISECONDS,
1425		new ArrayBlockingQueue<Runnable>(10));
1426	<	try {
1426	>	try (PoolCleaner cleaner = cleaner(e)) {
1427		Future<String> future = e.submit(new StringTask());
1428		String result = future.get();
1429		assertSame(TEST_STRING, result);
1431	–	} finally {
1432	–	joinPool(e);
1430		}
1431		}
1432
#	Line 1441 | Line 1438 | public class ThreadPoolExecutorSubclassT
1438		new CustomTPE(2, 2,
1439		LONG_DELAY_MS, MILLISECONDS,
1440		new ArrayBlockingQueue<Runnable>(10));
1441	<	try {
1441	>	try (PoolCleaner cleaner = cleaner(e)) {
1442		Future<?> future = e.submit(new NoOpRunnable());
1443		future.get();
1444		assertTrue(future.isDone());
1448	–	} finally {
1449	–	joinPool(e);
1445		}
1446		}
1447
#	Line 1458 | Line 1453 | public class ThreadPoolExecutorSubclassT
1453		new CustomTPE(2, 2,
1454		LONG_DELAY_MS, MILLISECONDS,
1455		new ArrayBlockingQueue<Runnable>(10));
1456	<	try {
1456	>	try (PoolCleaner cleaner = cleaner(e)) {
1457		Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
1458		String result = future.get();
1459		assertSame(TEST_STRING, result);
1465	–	} finally {
1466	–	joinPool(e);
1460		}
1461		}
1462
#	Line 1475 | Line 1468 | public class ThreadPoolExecutorSubclassT
1468		new CustomTPE(2, 2,
1469		LONG_DELAY_MS, MILLISECONDS,
1470		new ArrayBlockingQueue<Runnable>(10));
1471	<	try {
1472	<	e.invokeAny(null);
1473	<	shouldThrow();
1474	<	} catch (NullPointerException success) {
1475	<	} finally {
1483	<	joinPool(e);
1471	>	try (PoolCleaner cleaner = cleaner(e)) {
1472	>	try {
1473	>	e.invokeAny(null);
1474	>	shouldThrow();
1475	>	} catch (NullPointerException success) {}
1476		}
1477		}
1478
#	Line 1492 | Line 1484 | public class ThreadPoolExecutorSubclassT
1484		new CustomTPE(2, 2,
1485		LONG_DELAY_MS, MILLISECONDS,
1486		new ArrayBlockingQueue<Runnable>(10));
1487	<	try {
1488	<	e.invokeAny(new ArrayList<Callable<String>>());
1489	<	shouldThrow();
1490	<	} catch (IllegalArgumentException success) {
1491	<	} finally {
1500	<	joinPool(e);
1487	>	try (PoolCleaner cleaner = cleaner(e)) {
1488	>	try {
1489	>	e.invokeAny(new ArrayList<Callable<String>>());
1490	>	shouldThrow();
1491	>	} catch (IllegalArgumentException success) {}
1492		}
1493		}
1494
#	Line 1510 | Line 1501 | public class ThreadPoolExecutorSubclassT
1501		new CustomTPE(2, 2,
1502		LONG_DELAY_MS, MILLISECONDS,
1503		new ArrayBlockingQueue<Runnable>(10));
1504	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1505	<	l.add(latchAwaitingStringTask(latch));
1506	<	l.add(null);
1507	<	try {
1508	<	e.invokeAny(l);
1509	<	shouldThrow();
1510	<	} catch (NullPointerException success) {
1511	<	} finally {
1504	>	try (PoolCleaner cleaner = cleaner(e)) {
1505	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1506	>	l.add(latchAwaitingStringTask(latch));
1507	>	l.add(null);
1508	>	try {
1509	>	e.invokeAny(l);
1510	>	shouldThrow();
1511	>	} catch (NullPointerException success) {}
1512		latch.countDown();
1522	–	joinPool(e);
1513		}
1514		}
1515
#	Line 1531 | Line 1521 | public class ThreadPoolExecutorSubclassT
1521		new CustomTPE(2, 2,
1522		LONG_DELAY_MS, MILLISECONDS,
1523		new ArrayBlockingQueue<Runnable>(10));
1524	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1525	<	l.add(new NPETask());
1526	<	try {
1527	<	e.invokeAny(l);
1528	<	shouldThrow();
1529	<	} catch (ExecutionException success) {
1530	<	assertTrue(success.getCause() instanceof NullPointerException);
1531	<	} finally {
1532	<	joinPool(e);
1524	>	try (PoolCleaner cleaner = cleaner(e)) {
1525	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1526	>	l.add(new NPETask());
1527	>	try {
1528	>	e.invokeAny(l);
1529	>	shouldThrow();
1530	>	} catch (ExecutionException success) {
1531	>	assertTrue(success.getCause() instanceof NullPointerException);
1532	>	}
1533		}
1534		}
1535
#	Line 1551 | Line 1541 | public class ThreadPoolExecutorSubclassT
1541		new CustomTPE(2, 2,
1542		LONG_DELAY_MS, MILLISECONDS,
1543		new ArrayBlockingQueue<Runnable>(10));
1544	<	try {
1544	>	try (PoolCleaner cleaner = cleaner(e)) {
1545		List<Callable<String>> l = new ArrayList<Callable<String>>();
1546		l.add(new StringTask());
1547		l.add(new StringTask());
1548		String result = e.invokeAny(l);
1549		assertSame(TEST_STRING, result);
1560	–	} finally {
1561	–	joinPool(e);
1550		}
1551		}
1552
#	Line 1570 | Line 1558 | public class ThreadPoolExecutorSubclassT
1558		new CustomTPE(2, 2,
1559		LONG_DELAY_MS, MILLISECONDS,
1560		new ArrayBlockingQueue<Runnable>(10));
1561	<	try {
1562	<	e.invokeAll(null);
1563	<	shouldThrow();
1564	<	} catch (NullPointerException success) {
1565	<	} finally {
1578	<	joinPool(e);
1561	>	try (PoolCleaner cleaner = cleaner(e)) {
1562	>	try {
1563	>	e.invokeAll(null);
1564	>	shouldThrow();
1565	>	} catch (NullPointerException success) {}
1566		}
1567		}
1568
#	Line 1587 | Line 1574 | public class ThreadPoolExecutorSubclassT
1574		new CustomTPE(2, 2,
1575		LONG_DELAY_MS, MILLISECONDS,
1576		new ArrayBlockingQueue<Runnable>(10));
1577	<	try {
1577	>	try (PoolCleaner cleaner = cleaner(e)) {
1578		List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1579		assertTrue(r.isEmpty());
1593	–	} finally {
1594	–	joinPool(e);
1580		}
1581		}
1582
#	Line 1603 | Line 1588 | public class ThreadPoolExecutorSubclassT
1588		new CustomTPE(2, 2,
1589		LONG_DELAY_MS, MILLISECONDS,
1590		new ArrayBlockingQueue<Runnable>(10));
1591	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1592	<	l.add(new StringTask());
1593	<	l.add(null);
1594	<	try {
1595	<	e.invokeAll(l);
1596	<	shouldThrow();
1597	<	} catch (NullPointerException success) {
1598	<	} finally {
1614	<	joinPool(e);
1591	>	try (PoolCleaner cleaner = cleaner(e)) {
1592	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1593	>	l.add(new StringTask());
1594	>	l.add(null);
1595	>	try {
1596	>	e.invokeAll(l);
1597	>	shouldThrow();
1598	>	} catch (NullPointerException success) {}
1599		}
1600		}
1601
#	Line 1623 | Line 1607 | public class ThreadPoolExecutorSubclassT
1607		new CustomTPE(2, 2,
1608		LONG_DELAY_MS, MILLISECONDS,
1609		new ArrayBlockingQueue<Runnable>(10));
1610	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1611	<	l.add(new NPETask());
1612	<	List<Future<String>> futures = e.invokeAll(l);
1613	<	assertEquals(1, futures.size());
1614	<	try {
1615	<	futures.get(0).get();
1616	<	shouldThrow();
1617	<	} catch (ExecutionException success) {
1618	<	assertTrue(success.getCause() instanceof NullPointerException);
1619	<	} finally {
1620	<	joinPool(e);
1610	>	try (PoolCleaner cleaner = cleaner(e)) {
1611	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1612	>	l.add(new NPETask());
1613	>	List<Future<String>> futures = e.invokeAll(l);
1614	>	assertEquals(1, futures.size());
1615	>	try {
1616	>	futures.get(0).get();
1617	>	shouldThrow();
1618	>	} catch (ExecutionException success) {
1619	>	assertTrue(success.getCause() instanceof NullPointerException);
1620	>	}
1621		}
1622		}
1623
#	Line 1645 | Line 1629 | public class ThreadPoolExecutorSubclassT
1629		new CustomTPE(2, 2,
1630		LONG_DELAY_MS, MILLISECONDS,
1631		new ArrayBlockingQueue<Runnable>(10));
1632	<	try {
1632	>	try (PoolCleaner cleaner = cleaner(e)) {
1633		List<Callable<String>> l = new ArrayList<Callable<String>>();
1634		l.add(new StringTask());
1635		l.add(new StringTask());
#	Line 1653 | Line 1637 | public class ThreadPoolExecutorSubclassT
1637		assertEquals(2, futures.size());
1638		for (Future<String> future : futures)
1639		assertSame(TEST_STRING, future.get());
1656	–	} finally {
1657	–	joinPool(e);
1640		}
1641		}
1642
#	Line 1666 | Line 1648 | public class ThreadPoolExecutorSubclassT
1648		new CustomTPE(2, 2,
1649		LONG_DELAY_MS, MILLISECONDS,
1650		new ArrayBlockingQueue<Runnable>(10));
1651	<	try {
1652	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1653	<	shouldThrow();
1654	<	} catch (NullPointerException success) {
1655	<	} finally {
1674	<	joinPool(e);
1651	>	try (PoolCleaner cleaner = cleaner(e)) {
1652	>	try {
1653	>	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1654	>	shouldThrow();
1655	>	} catch (NullPointerException success) {}
1656		}
1657		}
1658
#	Line 1683 | Line 1664 | public class ThreadPoolExecutorSubclassT
1664		new CustomTPE(2, 2,
1665		LONG_DELAY_MS, MILLISECONDS,
1666		new ArrayBlockingQueue<Runnable>(10));
1667	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1668	<	l.add(new StringTask());
1669	<	try {
1670	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1671	<	shouldThrow();
1672	<	} catch (NullPointerException success) {
1673	<	} finally {
1693	<	joinPool(e);
1667	>	try (PoolCleaner cleaner = cleaner(e)) {
1668	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1669	>	l.add(new StringTask());
1670	>	try {
1671	>	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1672	>	shouldThrow();
1673	>	} catch (NullPointerException success) {}
1674		}
1675		}
1676
#	Line 1702 | Line 1682 | public class ThreadPoolExecutorSubclassT
1682		new CustomTPE(2, 2,
1683		LONG_DELAY_MS, MILLISECONDS,
1684		new ArrayBlockingQueue<Runnable>(10));
1685	<	try {
1686	<	e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1687	<	shouldThrow();
1688	<	} catch (IllegalArgumentException success) {
1689	<	} finally {
1690	<	joinPool(e);
1685	>	try (PoolCleaner cleaner = cleaner(e)) {
1686	>	try {
1687	>	e.invokeAny(new ArrayList<Callable<String>>(),
1688	>	MEDIUM_DELAY_MS, MILLISECONDS);
1689	>	shouldThrow();
1690	>	} catch (IllegalArgumentException success) {}
1691		}
1692		}
1693
#	Line 1720 | Line 1700 | public class ThreadPoolExecutorSubclassT
1700		new CustomTPE(2, 2,
1701		LONG_DELAY_MS, MILLISECONDS,
1702		new ArrayBlockingQueue<Runnable>(10));
1703	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1704	<	l.add(latchAwaitingStringTask(latch));
1705	<	l.add(null);
1706	<	try {
1707	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1708	<	shouldThrow();
1709	<	} catch (NullPointerException success) {
1710	<	} finally {
1703	>	try (PoolCleaner cleaner = cleaner(e)) {
1704	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1705	>	l.add(latchAwaitingStringTask(latch));
1706	>	l.add(null);
1707	>	try {
1708	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1709	>	shouldThrow();
1710	>	} catch (NullPointerException success) {}
1711		latch.countDown();
1732	–	joinPool(e);
1712		}
1713		}
1714
#	Line 1741 | Line 1720 | public class ThreadPoolExecutorSubclassT
1720		new CustomTPE(2, 2,
1721		LONG_DELAY_MS, MILLISECONDS,
1722		new ArrayBlockingQueue<Runnable>(10));
1723	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1724	<	l.add(new NPETask());
1725	<	try {
1726	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1727	<	shouldThrow();
1728	<	} catch (ExecutionException success) {
1729	<	assertTrue(success.getCause() instanceof NullPointerException);
1730	<	} finally {
1731	<	joinPool(e);
1723	>	try (PoolCleaner cleaner = cleaner(e)) {
1724	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1725	>	l.add(new NPETask());
1726	>	try {
1727	>	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1728	>	shouldThrow();
1729	>	} catch (ExecutionException success) {
1730	>	assertTrue(success.getCause() instanceof NullPointerException);
1731	>	}
1732		}
1733		}
1734
#	Line 1761 | Line 1740 | public class ThreadPoolExecutorSubclassT
1740		new CustomTPE(2, 2,
1741		LONG_DELAY_MS, MILLISECONDS,
1742		new ArrayBlockingQueue<Runnable>(10));
1743	<	try {
1743	>	try (PoolCleaner cleaner = cleaner(e)) {
1744		List<Callable<String>> l = new ArrayList<Callable<String>>();
1745		l.add(new StringTask());
1746		l.add(new StringTask());
1747		String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1748		assertSame(TEST_STRING, result);
1770	–	} finally {
1771	–	joinPool(e);
1749		}
1750		}
1751
#	Line 1780 | Line 1757 | public class ThreadPoolExecutorSubclassT
1757		new CustomTPE(2, 2,
1758		LONG_DELAY_MS, MILLISECONDS,
1759		new ArrayBlockingQueue<Runnable>(10));
1760	<	try {
1761	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1762	<	shouldThrow();
1763	<	} catch (NullPointerException success) {
1764	<	} finally {
1788	<	joinPool(e);
1760	>	try (PoolCleaner cleaner = cleaner(e)) {
1761	>	try {
1762	>	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1763	>	shouldThrow();
1764	>	} catch (NullPointerException success) {}
1765		}
1766		}
1767
#	Line 1797 | Line 1773 | public class ThreadPoolExecutorSubclassT
1773		new CustomTPE(2, 2,
1774		LONG_DELAY_MS, MILLISECONDS,
1775		new ArrayBlockingQueue<Runnable>(10));
1776	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1777	<	l.add(new StringTask());
1778	<	try {
1779	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1780	<	shouldThrow();
1781	<	} catch (NullPointerException success) {
1782	<	} finally {
1807	<	joinPool(e);
1776	>	try (PoolCleaner cleaner = cleaner(e)) {
1777	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1778	>	l.add(new StringTask());
1779	>	try {
1780	>	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1781	>	shouldThrow();
1782	>	} catch (NullPointerException success) {}
1783		}
1784		}
1785
#	Line 1816 | Line 1791 | public class ThreadPoolExecutorSubclassT
1791		new CustomTPE(2, 2,
1792		LONG_DELAY_MS, MILLISECONDS,
1793		new ArrayBlockingQueue<Runnable>(10));
1794	<	try {
1795	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
1794	>	try (PoolCleaner cleaner = cleaner(e)) {
1795	>	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1796	>	MEDIUM_DELAY_MS, MILLISECONDS);
1797		assertTrue(r.isEmpty());
1822	–	} finally {
1823	–	joinPool(e);
1798		}
1799		}
1800
#	Line 1832 | Line 1806 | public class ThreadPoolExecutorSubclassT
1806		new CustomTPE(2, 2,
1807		LONG_DELAY_MS, MILLISECONDS,
1808		new ArrayBlockingQueue<Runnable>(10));
1809	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1810	<	l.add(new StringTask());
1811	<	l.add(null);
1812	<	try {
1813	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1814	<	shouldThrow();
1815	<	} catch (NullPointerException success) {
1816	<	} finally {
1843	<	joinPool(e);
1809	>	try (PoolCleaner cleaner = cleaner(e)) {
1810	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1811	>	l.add(new StringTask());
1812	>	l.add(null);
1813	>	try {
1814	>	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1815	>	shouldThrow();
1816	>	} catch (NullPointerException success) {}
1817		}
1818		}
1819
#	Line 1852 | Line 1825 | public class ThreadPoolExecutorSubclassT
1825		new CustomTPE(2, 2,
1826		LONG_DELAY_MS, MILLISECONDS,
1827		new ArrayBlockingQueue<Runnable>(10));
1828	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1829	<	l.add(new NPETask());
1830	<	List<Future<String>> futures =
1831	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1832	<	assertEquals(1, futures.size());
1833	<	try {
1834	<	futures.get(0).get();
1835	<	shouldThrow();
1836	<	} catch (ExecutionException success) {
1837	<	assertTrue(success.getCause() instanceof NullPointerException);
1838	<	} finally {
1839	<	joinPool(e);
1828	>	try (PoolCleaner cleaner = cleaner(e)) {
1829	>	List<Callable<String>> l = new ArrayList<Callable<String>>();
1830	>	l.add(new NPETask());
1831	>	List<Future<String>> futures =
1832	>	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1833	>	assertEquals(1, futures.size());
1834	>	try {
1835	>	futures.get(0).get();
1836	>	shouldThrow();
1837	>	} catch (ExecutionException success) {
1838	>	assertTrue(success.getCause() instanceof NullPointerException);
1839	>	}
1840		}
1841		}
1842
#	Line 1875 | Line 1848 | public class ThreadPoolExecutorSubclassT
1848		new CustomTPE(2, 2,
1849		LONG_DELAY_MS, MILLISECONDS,
1850		new ArrayBlockingQueue<Runnable>(10));
1851	<	try {
1851	>	try (PoolCleaner cleaner = cleaner(e)) {
1852		List<Callable<String>> l = new ArrayList<Callable<String>>();
1853		l.add(new StringTask());
1854		l.add(new StringTask());
#	Line 1884 | Line 1857 | public class ThreadPoolExecutorSubclassT
1857		assertEquals(2, futures.size());
1858		for (Future<String> future : futures)
1859		assertSame(TEST_STRING, future.get());
1887	–	} finally {
1888	–	joinPool(e);
1860		}
1861		}
1862
#	Line 1897 | Line 1868 | public class ThreadPoolExecutorSubclassT
1868		new CustomTPE(2, 2,
1869		LONG_DELAY_MS, MILLISECONDS,
1870		new ArrayBlockingQueue<Runnable>(10));
1871	<	try {
1871	>	try (PoolCleaner cleaner = cleaner(e)) {
1872		for (long timeout = timeoutMillis();;) {
1873		List<Callable<String>> tasks = new ArrayList<>();
1874		tasks.add(new StringTask("0"));
#	Line 1921 | Line 1892 | public class ThreadPoolExecutorSubclassT
1892		fail("expected exactly one task to be cancelled");
1893		}
1894		}
1924	–	} finally {
1925	–	joinPool(e);
1895		}
1896		}
1897
#	Line 1936 | Line 1905 | public class ThreadPoolExecutorSubclassT
1905		LONG_DELAY_MS, MILLISECONDS,
1906		new LinkedBlockingQueue<Runnable>(),
1907		new FailingThreadFactory());
1908	<	try {
1908	>	try (PoolCleaner cleaner = cleaner(e)) {
1909		final int TASKS = 100;
1910		final CountDownLatch done = new CountDownLatch(TASKS);
1911		for (int k = 0; k < TASKS; ++k)
#	Line 1945 | Line 1914 | public class ThreadPoolExecutorSubclassT
1914		done.countDown();
1915		}});
1916		assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1948	–	} finally {
1949	–	joinPool(e);
1917		}
1918		}
1919
#	Line 1958 | Line 1925 | public class ThreadPoolExecutorSubclassT
1925		new CustomTPE(2, 2,
1926		1000, MILLISECONDS,
1927		new ArrayBlockingQueue<Runnable>(10));
1928	<	assertFalse(p.allowsCoreThreadTimeOut());
1929	<	joinPool(p);
1928	>	try (PoolCleaner cleaner = cleaner(p)) {
1929	>	assertFalse(p.allowsCoreThreadTimeOut());
1930	>	}
1931		}
1932
1933		/**
#	Line 1971 | Line 1939 | public class ThreadPoolExecutorSubclassT
1939		new CustomTPE(2, 10,
1940		keepAliveTime, MILLISECONDS,
1941		new ArrayBlockingQueue<Runnable>(10));
1942	<	final CountDownLatch threadStarted = new CountDownLatch(1);
1943	<	try {
1942	>	try (PoolCleaner cleaner = cleaner(p)) {
1943	>	final CountDownLatch threadStarted = new CountDownLatch(1);
1944		p.allowCoreThreadTimeOut(true);
1945		p.execute(new CheckedRunnable() {
1946		public void realRun() {
#	Line 1987 | Line 1955 | public class ThreadPoolExecutorSubclassT
1955		Thread.yield();
1956		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1957		assertEquals(0, p.getPoolSize());
1990	–	} finally {
1991	–	joinPool(p);
1958		}
1959		}
1960
#	Line 2001 | Line 1967 | public class ThreadPoolExecutorSubclassT
1967		new CustomTPE(2, 10,
1968		keepAliveTime, MILLISECONDS,
1969		new ArrayBlockingQueue<Runnable>(10));
1970	<	final CountDownLatch threadStarted = new CountDownLatch(1);
1971	<	try {
1970	>	try (PoolCleaner cleaner = cleaner(p)) {
1971	>	final CountDownLatch threadStarted = new CountDownLatch(1);
1972		p.allowCoreThreadTimeOut(false);
1973		p.execute(new CheckedRunnable() {
1974		public void realRun() throws InterruptedException {
#	Line 2011 | Line 1977 | public class ThreadPoolExecutorSubclassT
1977		}});
1978		delay(2 * keepAliveTime);
1979		assertTrue(p.getPoolSize() >= 1);
2014	–	} finally {
2015	–	joinPool(p);
1980		}
1981		}
1982
#	Line 2025 | Line 1989 | public class ThreadPoolExecutorSubclassT
1989		new CustomTPE(1, 1,
1990		LONG_DELAY_MS, MILLISECONDS,
1991		new LinkedBlockingQueue<Runnable>());
1992	<	try {
1992	>	try (PoolCleaner cleaner = cleaner(e)) {
1993		final CountDownLatch blockerStarted = new CountDownLatch(1);
1994		final CountDownLatch done = new CountDownLatch(1);
1995		final List<Future<?>> futures = new ArrayList<>();
#	Line 2052 | Line 2016 | public class ThreadPoolExecutorSubclassT
2016		assertTrue(future.isDone());
2017		}
2018		done.countDown();
2055	–	} finally {
2056	–	joinPool(e);
2019		}
2020		}
2021

Diff Legend

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