ViewVC Help

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

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

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.110 by jsr166, Tue Oct 6 16:39:06 2015 UTC vs.
Revision 1.120 by jsr166, Sat Jul 15 18:17:40 2017 UTC

#	Line 11 | Line 11 | import static java.util.concurrent.TimeU
11		import static java.util.concurrent.TimeUnit.SECONDS;
12
13		import java.util.ArrayList;
14	+	import java.util.Collection;
15	+	import java.util.Collections;
16		import java.util.List;
17		import java.util.concurrent.ArrayBlockingQueue;
18		import java.util.concurrent.BlockingQueue;
#	Line 18 | Line 20 | import java.util.concurrent.Callable;
20		import java.util.concurrent.CancellationException;
21		import java.util.concurrent.CountDownLatch;
22		import java.util.concurrent.ExecutionException;
21	–	import java.util.concurrent.Executors;
23		import java.util.concurrent.ExecutorService;
24		import java.util.concurrent.Future;
25		import java.util.concurrent.FutureTask;
#	Line 28 | Line 29 | import java.util.concurrent.RejectedExec
29		import java.util.concurrent.SynchronousQueue;
30		import java.util.concurrent.ThreadFactory;
31		import java.util.concurrent.ThreadPoolExecutor;
31	–	import java.util.concurrent.TimeUnit;
32		import java.util.concurrent.atomic.AtomicInteger;
33
34		import junit.framework.Test;
#	Line 92 | Line 92 | public class ThreadPoolExecutorTest exte
92		final Runnable task = new CheckedRunnable() {
93		public void realRun() { done.countDown(); }};
94		p.execute(task);
95	<	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
95	>	await(done);
96		}
97		}
98
#	Line 186 | Line 186 | public class ThreadPoolExecutorTest exte
186		public void realRun() throws InterruptedException {
187		threadStarted.countDown();
188		assertEquals(0, p.getCompletedTaskCount());
189	<	threadProceed.await();
189	>	await(threadProceed);
190		threadDone.countDown();
191		}});
192		await(threadStarted);
193		assertEquals(0, p.getCompletedTaskCount());
194		threadProceed.countDown();
195	<	threadDone.await();
195	>	await(threadDone);
196		long startTime = System.nanoTime();
197		while (p.getCompletedTaskCount() != 1) {
198		if (millisElapsedSince(startTime) > LONG_DELAY_MS)
#	Line 276 | Line 276 | public class ThreadPoolExecutorTest exte
276		}
277
278		/**
279	+	* The default rejected execution handler is AbortPolicy.
280	+	*/
281	+	public void testDefaultRejectedExecutionHandler() {
282	+	final ThreadPoolExecutor p =
283	+	new ThreadPoolExecutor(1, 2,
284	+	LONG_DELAY_MS, MILLISECONDS,
285	+	new ArrayBlockingQueue<Runnable>(10));
286	+	try (PoolCleaner cleaner = cleaner(p)) {
287	+	assertTrue(p.getRejectedExecutionHandler()
288	+	instanceof ThreadPoolExecutor.AbortPolicy);
289	+	}
290	+	}
291	+
292	+	/**
293		* getRejectedExecutionHandler returns handler in constructor if not set
294		*/
295		public void testGetRejectedExecutionHandler() {
#	Line 458 | Line 472 | public class ThreadPoolExecutorTest exte
472		assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
473		assertFalse(p.awaitTermination(-1L, NANOSECONDS));
474		assertFalse(p.awaitTermination(-1L, MILLISECONDS));
475	<	assertFalse(p.awaitTermination(0L, NANOSECONDS));
476	<	assertFalse(p.awaitTermination(0L, MILLISECONDS));
475	>	assertFalse(p.awaitTermination(randomExpiredTimeout(),
476	>	randomTimeUnit()));
477		long timeoutNanos = 999999L;
478		long startTime = System.nanoTime();
479		assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
#	Line 537 | Line 551 | public class ThreadPoolExecutorTest exte
551		*/
552		public void testGetQueue() throws InterruptedException {
553		final CountDownLatch done = new CountDownLatch(1);
554	<	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
554	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
555		final ThreadPoolExecutor p =
556		new ThreadPoolExecutor(1, 1,
557		LONG_DELAY_MS, MILLISECONDS,
#	Line 569 | Line 583 | public class ThreadPoolExecutorTest exte
583		*/
584		public void testRemove() throws InterruptedException {
585		final CountDownLatch done = new CountDownLatch(1);
586	<	BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
586	>	BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
587		final ThreadPoolExecutor p =
588		new ThreadPoolExecutor(1, 1,
589		LONG_DELAY_MS, MILLISECONDS,
#	Line 604 | Line 618 | public class ThreadPoolExecutorTest exte
618		public void testPurge() throws InterruptedException {
619		final CountDownLatch threadStarted = new CountDownLatch(1);
620		final CountDownLatch done = new CountDownLatch(1);
621	<	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
621	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
622		final ThreadPoolExecutor p =
623		new ThreadPoolExecutor(1, 1,
624		LONG_DELAY_MS, MILLISECONDS,
#	Line 1113 | Line 1127 | public class ThreadPoolExecutorTest exte
1127		await(done);
1128		}};
1129		for (int i = 0; i < 2; ++i)
1130	<	p.submit(Executors.callable(task));
1130	>	p.execute(task);
1131		for (int i = 0; i < 2; ++i) {
1132		try {
1133		p.execute(task);
#	Line 1483 | Line 1497 | public class ThreadPoolExecutorTest exte
1497		}
1498
1499		/**
1500	<	* invokeAny(empty collection) throws IAE
1500	>	* invokeAny(empty collection) throws IllegalArgumentException
1501		*/
1502		public void testInvokeAny2() throws Exception {
1503		final ExecutorService e =
#	Line 1508 | Line 1522 | public class ThreadPoolExecutorTest exte
1522		LONG_DELAY_MS, MILLISECONDS,
1523		new ArrayBlockingQueue<Runnable>(10));
1524		try (PoolCleaner cleaner = cleaner(e)) {
1525	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1525	>	List<Callable<String>> l = new ArrayList<>();
1526		l.add(latchAwaitingStringTask(latch));
1527		l.add(null);
1528		try {
#	Line 1528 | Line 1542 | public class ThreadPoolExecutorTest exte
1542		LONG_DELAY_MS, MILLISECONDS,
1543		new ArrayBlockingQueue<Runnable>(10));
1544		try (PoolCleaner cleaner = cleaner(e)) {
1545	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1545	>	List<Callable<String>> l = new ArrayList<>();
1546		l.add(new NPETask());
1547		try {
1548		e.invokeAny(l);
#	Line 1548 | Line 1562 | public class ThreadPoolExecutorTest exte
1562		LONG_DELAY_MS, MILLISECONDS,
1563		new ArrayBlockingQueue<Runnable>(10));
1564		try (PoolCleaner cleaner = cleaner(e)) {
1565	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1565	>	List<Callable<String>> l = new ArrayList<>();
1566		l.add(new StringTask());
1567		l.add(new StringTask());
1568		String result = e.invokeAny(l);
#	Line 1573 | Line 1587 | public class ThreadPoolExecutorTest exte
1587		}
1588
1589		/**
1590	<	* invokeAll(empty collection) returns empty collection
1590	>	* invokeAll(empty collection) returns empty list
1591		*/
1592		public void testInvokeAll2() throws InterruptedException {
1593		final ExecutorService e =
1594		new ThreadPoolExecutor(2, 2,
1595		LONG_DELAY_MS, MILLISECONDS,
1596		new ArrayBlockingQueue<Runnable>(10));
1597	+	final Collection<Callable<String>> emptyCollection
1598	+	= Collections.emptyList();
1599		try (PoolCleaner cleaner = cleaner(e)) {
1600	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
1600	>	List<Future<String>> r = e.invokeAll(emptyCollection);
1601		assertTrue(r.isEmpty());
1602		}
1603		}
#	Line 1595 | Line 1611 | public class ThreadPoolExecutorTest exte
1611		LONG_DELAY_MS, MILLISECONDS,
1612		new ArrayBlockingQueue<Runnable>(10));
1613		try (PoolCleaner cleaner = cleaner(e)) {
1614	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1614	>	List<Callable<String>> l = new ArrayList<>();
1615		l.add(new StringTask());
1616		l.add(null);
1617		try {
#	Line 1614 | Line 1630 | public class ThreadPoolExecutorTest exte
1630		LONG_DELAY_MS, MILLISECONDS,
1631		new ArrayBlockingQueue<Runnable>(10));
1632		try (PoolCleaner cleaner = cleaner(e)) {
1633	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1633	>	List<Callable<String>> l = new ArrayList<>();
1634		l.add(new NPETask());
1635		List<Future<String>> futures = e.invokeAll(l);
1636		assertEquals(1, futures.size());
#	Line 1636 | Line 1652 | public class ThreadPoolExecutorTest exte
1652		LONG_DELAY_MS, MILLISECONDS,
1653		new ArrayBlockingQueue<Runnable>(10));
1654		try (PoolCleaner cleaner = cleaner(e)) {
1655	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1655	>	List<Callable<String>> l = new ArrayList<>();
1656		l.add(new StringTask());
1657		l.add(new StringTask());
1658		List<Future<String>> futures = e.invokeAll(l);
#	Line 1656 | Line 1672 | public class ThreadPoolExecutorTest exte
1672		new ArrayBlockingQueue<Runnable>(10));
1673		try (PoolCleaner cleaner = cleaner(e)) {
1674		try {
1675	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
1675	>	e.invokeAny(null, randomTimeout(), randomTimeUnit());
1676		shouldThrow();
1677		} catch (NullPointerException success) {}
1678		}
#	Line 1671 | Line 1687 | public class ThreadPoolExecutorTest exte
1687		LONG_DELAY_MS, MILLISECONDS,
1688		new ArrayBlockingQueue<Runnable>(10));
1689		try (PoolCleaner cleaner = cleaner(e)) {
1690	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1690	>	List<Callable<String>> l = new ArrayList<>();
1691		l.add(new StringTask());
1692		try {
1693	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
1693	>	e.invokeAny(l, randomTimeout(), null);
1694		shouldThrow();
1695		} catch (NullPointerException success) {}
1696		}
1697		}
1698
1699		/**
1700	<	* timed invokeAny(empty collection) throws IAE
1700	>	* timed invokeAny(empty collection) throws IllegalArgumentException
1701		*/
1702		public void testTimedInvokeAny2() throws Exception {
1703		final ExecutorService e =
#	Line 1691 | Line 1707 | public class ThreadPoolExecutorTest exte
1707		try (PoolCleaner cleaner = cleaner(e)) {
1708		try {
1709		e.invokeAny(new ArrayList<Callable<String>>(),
1710	<	MEDIUM_DELAY_MS, MILLISECONDS);
1710	>	randomTimeout(), randomTimeUnit());
1711		shouldThrow();
1712		} catch (IllegalArgumentException success) {}
1713		}
1714		}
1715
1716		/**
1717	<	* timed invokeAny(c) throws NPE if c has null elements
1717	>	* timed invokeAny(c) throws NullPointerException if c has null elements
1718		*/
1719		public void testTimedInvokeAny3() throws Exception {
1720		final CountDownLatch latch = new CountDownLatch(1);
#	Line 1707 | Line 1723 | public class ThreadPoolExecutorTest exte
1723		LONG_DELAY_MS, MILLISECONDS,
1724		new ArrayBlockingQueue<Runnable>(10));
1725		try (PoolCleaner cleaner = cleaner(e)) {
1726	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1726	>	List<Callable<String>> l = new ArrayList<>();
1727		l.add(latchAwaitingStringTask(latch));
1728		l.add(null);
1729		try {
1730	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1730	>	e.invokeAny(l, randomTimeout(), randomTimeUnit());
1731		shouldThrow();
1732		} catch (NullPointerException success) {}
1733		latch.countDown();
#	Line 1727 | Line 1743 | public class ThreadPoolExecutorTest exte
1743		LONG_DELAY_MS, MILLISECONDS,
1744		new ArrayBlockingQueue<Runnable>(10));
1745		try (PoolCleaner cleaner = cleaner(e)) {
1746	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1746	>	long startTime = System.nanoTime();
1747	>	List<Callable<String>> l = new ArrayList<>();
1748		l.add(new NPETask());
1749		try {
1750	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1750	>	e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1751		shouldThrow();
1752		} catch (ExecutionException success) {
1753		assertTrue(success.getCause() instanceof NullPointerException);
1754		}
1755	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1756		}
1757		}
1758
#	Line 1747 | Line 1765 | public class ThreadPoolExecutorTest exte
1765		LONG_DELAY_MS, MILLISECONDS,
1766		new ArrayBlockingQueue<Runnable>(10));
1767		try (PoolCleaner cleaner = cleaner(e)) {
1768	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1768	>	long startTime = System.nanoTime();
1769	>	List<Callable<String>> l = new ArrayList<>();
1770		l.add(new StringTask());
1771		l.add(new StringTask());
1772	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
1772	>	String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
1773		assertSame(TEST_STRING, result);
1774	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1775		}
1776		}
1777
#	Line 1765 | Line 1785 | public class ThreadPoolExecutorTest exte
1785		new ArrayBlockingQueue<Runnable>(10));
1786		try (PoolCleaner cleaner = cleaner(e)) {
1787		try {
1788	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
1788	>	e.invokeAll(null, randomTimeout(), randomTimeUnit());
1789		shouldThrow();
1790		} catch (NullPointerException success) {}
1791		}
#	Line 1780 | Line 1800 | public class ThreadPoolExecutorTest exte
1800		LONG_DELAY_MS, MILLISECONDS,
1801		new ArrayBlockingQueue<Runnable>(10));
1802		try (PoolCleaner cleaner = cleaner(e)) {
1803	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1803	>	List<Callable<String>> l = new ArrayList<>();
1804		l.add(new StringTask());
1805		try {
1806	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
1806	>	e.invokeAll(l, randomTimeout(), null);
1807		shouldThrow();
1808		} catch (NullPointerException success) {}
1809		}
1810		}
1811
1812		/**
1813	<	* timed invokeAll(empty collection) returns empty collection
1813	>	* timed invokeAll(empty collection) returns empty list
1814		*/
1815		public void testTimedInvokeAll2() throws InterruptedException {
1816		final ExecutorService e =
1817		new ThreadPoolExecutor(2, 2,
1818		LONG_DELAY_MS, MILLISECONDS,
1819		new ArrayBlockingQueue<Runnable>(10));
1820	+	final Collection<Callable<String>> emptyCollection
1821	+	= Collections.emptyList();
1822		try (PoolCleaner cleaner = cleaner(e)) {
1823	<	List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(),
1824	<	MEDIUM_DELAY_MS, MILLISECONDS);
1823	>	List<Future<String>> r =
1824	>	e.invokeAll(emptyCollection, randomTimeout(), randomTimeUnit());
1825		assertTrue(r.isEmpty());
1826		}
1827		}
#	Line 1813 | Line 1835 | public class ThreadPoolExecutorTest exte
1835		LONG_DELAY_MS, MILLISECONDS,
1836		new ArrayBlockingQueue<Runnable>(10));
1837		try (PoolCleaner cleaner = cleaner(e)) {
1838	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1838	>	List<Callable<String>> l = new ArrayList<>();
1839		l.add(new StringTask());
1840		l.add(null);
1841		try {
1842	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
1842	>	e.invokeAll(l, randomTimeout(), randomTimeUnit());
1843		shouldThrow();
1844		} catch (NullPointerException success) {}
1845		}
#	Line 1832 | Line 1854 | public class ThreadPoolExecutorTest exte
1854		LONG_DELAY_MS, MILLISECONDS,
1855		new ArrayBlockingQueue<Runnable>(10));
1856		try (PoolCleaner cleaner = cleaner(e)) {
1857	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1857	>	List<Callable<String>> l = new ArrayList<>();
1858		l.add(new NPETask());
1859		List<Future<String>> futures =
1860		e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1855 | Line 1877 | public class ThreadPoolExecutorTest exte
1877		LONG_DELAY_MS, MILLISECONDS,
1878		new ArrayBlockingQueue<Runnable>(10));
1879		try (PoolCleaner cleaner = cleaner(e)) {
1880	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1880	>	List<Callable<String>> l = new ArrayList<>();
1881		l.add(new StringTask());
1882		l.add(new StringTask());
1883		List<Future<String>> futures =
#	Line 1925 | Line 1947 | public class ThreadPoolExecutorTest exte
1947		public void realRun() {
1948		done.countDown();
1949		}});
1950	<	assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
1950	>	await(done);
1951		}
1952		}
1953
#	Line 2018 | Line 2040 | public class ThreadPoolExecutorTest exte
2040		}
2041		}
2042		// enough time to run all tasks
2043	<	assertTrue(done.await(nTasks * SHORT_DELAY_MS, MILLISECONDS));
2043	>	await(done, nTasks * SHORT_DELAY_MS);
2044		}
2045		}
2046
#	Line 2059 | Line 2081 | public class ThreadPoolExecutorTest exte
2081		}
2082		}
2083
2084	+	public void testAbortPolicy() {
2085	+	final RejectedExecutionHandler handler =
2086	+	new ThreadPoolExecutor.AbortPolicy();
2087	+	final ThreadPoolExecutor p =
2088	+	new ThreadPoolExecutor(1, 1,
2089	+	LONG_DELAY_MS, MILLISECONDS,
2090	+	new ArrayBlockingQueue<Runnable>(10));
2091	+	final TrackedNoOpRunnable r = new TrackedNoOpRunnable();
2092	+	try {
2093	+	handler.rejectedExecution(r, p);
2094	+	shouldThrow();
2095	+	} catch (RejectedExecutionException success) {}
2096	+	assertFalse(r.done);
2097	+	assertEquals(0, p.getTaskCount());
2098	+	assertTrue(p.getQueue().isEmpty());
2099	+	}
2100	+
2101		}

Diff Legend

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