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.112 by jsr166, Thu Oct 8 03:08:38 2015 UTC vs.
Revision 1.115 by jsr166, Mon Mar 20 00:21:54 2017 UTC

#	Line 18 | Line 18 | import java.util.concurrent.Callable;
18		import java.util.concurrent.CancellationException;
19		import java.util.concurrent.CountDownLatch;
20		import java.util.concurrent.ExecutionException;
21	–	import java.util.concurrent.Executors;
21		import java.util.concurrent.ExecutorService;
22		import java.util.concurrent.Future;
23		import java.util.concurrent.FutureTask;
#	Line 28 | Line 27 | import java.util.concurrent.RejectedExec
27		import java.util.concurrent.SynchronousQueue;
28		import java.util.concurrent.ThreadFactory;
29		import java.util.concurrent.ThreadPoolExecutor;
31	–	import java.util.concurrent.TimeUnit;
30		import java.util.concurrent.atomic.AtomicInteger;
31
32		import junit.framework.Test;
#	Line 537 | Line 535 | public class ThreadPoolExecutorTest exte
535		*/
536		public void testGetQueue() throws InterruptedException {
537		final CountDownLatch done = new CountDownLatch(1);
538	<	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
538	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
539		final ThreadPoolExecutor p =
540		new ThreadPoolExecutor(1, 1,
541		LONG_DELAY_MS, MILLISECONDS,
#	Line 569 | Line 567 | public class ThreadPoolExecutorTest exte
567		*/
568		public void testRemove() throws InterruptedException {
569		final CountDownLatch done = new CountDownLatch(1);
570	<	BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
570	>	BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
571		final ThreadPoolExecutor p =
572		new ThreadPoolExecutor(1, 1,
573		LONG_DELAY_MS, MILLISECONDS,
#	Line 604 | Line 602 | public class ThreadPoolExecutorTest exte
602		public void testPurge() throws InterruptedException {
603		final CountDownLatch threadStarted = new CountDownLatch(1);
604		final CountDownLatch done = new CountDownLatch(1);
605	<	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10);
605	>	final BlockingQueue<Runnable> q = new ArrayBlockingQueue<>(10);
606		final ThreadPoolExecutor p =
607		new ThreadPoolExecutor(1, 1,
608		LONG_DELAY_MS, MILLISECONDS,
#	Line 1113 | Line 1111 | public class ThreadPoolExecutorTest exte
1111		await(done);
1112		}};
1113		for (int i = 0; i < 2; ++i)
1114	<	p.submit(Executors.callable(task));
1114	>	p.execute(task);
1115		for (int i = 0; i < 2; ++i) {
1116		try {
1117		p.execute(task);
#	Line 1508 | Line 1506 | public class ThreadPoolExecutorTest exte
1506		LONG_DELAY_MS, MILLISECONDS,
1507		new ArrayBlockingQueue<Runnable>(10));
1508		try (PoolCleaner cleaner = cleaner(e)) {
1509	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1509	>	List<Callable<String>> l = new ArrayList<>();
1510		l.add(latchAwaitingStringTask(latch));
1511		l.add(null);
1512		try {
#	Line 1528 | Line 1526 | public class ThreadPoolExecutorTest exte
1526		LONG_DELAY_MS, MILLISECONDS,
1527		new ArrayBlockingQueue<Runnable>(10));
1528		try (PoolCleaner cleaner = cleaner(e)) {
1529	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1529	>	List<Callable<String>> l = new ArrayList<>();
1530		l.add(new NPETask());
1531		try {
1532		e.invokeAny(l);
#	Line 1548 | Line 1546 | public class ThreadPoolExecutorTest exte
1546		LONG_DELAY_MS, MILLISECONDS,
1547		new ArrayBlockingQueue<Runnable>(10));
1548		try (PoolCleaner cleaner = cleaner(e)) {
1549	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1549	>	List<Callable<String>> l = new ArrayList<>();
1550		l.add(new StringTask());
1551		l.add(new StringTask());
1552		String result = e.invokeAny(l);
#	Line 1595 | Line 1593 | public class ThreadPoolExecutorTest exte
1593		LONG_DELAY_MS, MILLISECONDS,
1594		new ArrayBlockingQueue<Runnable>(10));
1595		try (PoolCleaner cleaner = cleaner(e)) {
1596	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1596	>	List<Callable<String>> l = new ArrayList<>();
1597		l.add(new StringTask());
1598		l.add(null);
1599		try {
#	Line 1614 | Line 1612 | public class ThreadPoolExecutorTest exte
1612		LONG_DELAY_MS, MILLISECONDS,
1613		new ArrayBlockingQueue<Runnable>(10));
1614		try (PoolCleaner cleaner = cleaner(e)) {
1615	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1615	>	List<Callable<String>> l = new ArrayList<>();
1616		l.add(new NPETask());
1617		List<Future<String>> futures = e.invokeAll(l);
1618		assertEquals(1, futures.size());
#	Line 1636 | Line 1634 | public class ThreadPoolExecutorTest exte
1634		LONG_DELAY_MS, MILLISECONDS,
1635		new ArrayBlockingQueue<Runnable>(10));
1636		try (PoolCleaner cleaner = cleaner(e)) {
1637	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1637	>	List<Callable<String>> l = new ArrayList<>();
1638		l.add(new StringTask());
1639		l.add(new StringTask());
1640		List<Future<String>> futures = e.invokeAll(l);
#	Line 1671 | Line 1669 | public class ThreadPoolExecutorTest exte
1669		LONG_DELAY_MS, MILLISECONDS,
1670		new ArrayBlockingQueue<Runnable>(10));
1671		try (PoolCleaner cleaner = cleaner(e)) {
1672	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1672	>	List<Callable<String>> l = new ArrayList<>();
1673		l.add(new StringTask());
1674		try {
1675		e.invokeAny(l, MEDIUM_DELAY_MS, null);
#	Line 1707 | Line 1705 | public class ThreadPoolExecutorTest exte
1705		LONG_DELAY_MS, MILLISECONDS,
1706		new ArrayBlockingQueue<Runnable>(10));
1707		try (PoolCleaner cleaner = cleaner(e)) {
1708	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1708	>	List<Callable<String>> l = new ArrayList<>();
1709		l.add(latchAwaitingStringTask(latch));
1710		l.add(null);
1711		try {
#	Line 1728 | Line 1726 | public class ThreadPoolExecutorTest exte
1726		new ArrayBlockingQueue<Runnable>(10));
1727		try (PoolCleaner cleaner = cleaner(e)) {
1728		long startTime = System.nanoTime();
1729	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1729	>	List<Callable<String>> l = new ArrayList<>();
1730		l.add(new NPETask());
1731		try {
1732		e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1750 | Line 1748 | public class ThreadPoolExecutorTest exte
1748		new ArrayBlockingQueue<Runnable>(10));
1749		try (PoolCleaner cleaner = cleaner(e)) {
1750		long startTime = System.nanoTime();
1751	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1751	>	List<Callable<String>> l = new ArrayList<>();
1752		l.add(new StringTask());
1753		l.add(new StringTask());
1754		String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1784 | Line 1782 | public class ThreadPoolExecutorTest exte
1782		LONG_DELAY_MS, MILLISECONDS,
1783		new ArrayBlockingQueue<Runnable>(10));
1784		try (PoolCleaner cleaner = cleaner(e)) {
1785	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1785	>	List<Callable<String>> l = new ArrayList<>();
1786		l.add(new StringTask());
1787		try {
1788		e.invokeAll(l, MEDIUM_DELAY_MS, null);
#	Line 1817 | Line 1815 | public class ThreadPoolExecutorTest exte
1815		LONG_DELAY_MS, MILLISECONDS,
1816		new ArrayBlockingQueue<Runnable>(10));
1817		try (PoolCleaner cleaner = cleaner(e)) {
1818	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1818	>	List<Callable<String>> l = new ArrayList<>();
1819		l.add(new StringTask());
1820		l.add(null);
1821		try {
#	Line 1836 | Line 1834 | public class ThreadPoolExecutorTest exte
1834		LONG_DELAY_MS, MILLISECONDS,
1835		new ArrayBlockingQueue<Runnable>(10));
1836		try (PoolCleaner cleaner = cleaner(e)) {
1837	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1837	>	List<Callable<String>> l = new ArrayList<>();
1838		l.add(new NPETask());
1839		List<Future<String>> futures =
1840		e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 1859 | Line 1857 | public class ThreadPoolExecutorTest exte
1857		LONG_DELAY_MS, MILLISECONDS,
1858		new ArrayBlockingQueue<Runnable>(10));
1859		try (PoolCleaner cleaner = cleaner(e)) {
1860	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
1860	>	List<Callable<String>> l = new ArrayList<>();
1861		l.add(new StringTask());
1862		l.add(new StringTask());
1863		List<Future<String>> futures =

Diff Legend

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