ViewVC Help

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

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

Comparing jsr166/src/test/tck/ExecutorCompletionServiceTest.java (file contents):
Revision 1.20 by jsr166, Sun Feb 22 04:34:44 2015 UTC vs.
Revision 1.28 by jsr166, Sat Mar 25 21:41:10 2017 UTC

#	Line 10 | Line 10 | import static java.util.concurrent.TimeU
10
11		import java.util.concurrent.ArrayBlockingQueue;
12		import java.util.concurrent.Callable;
13	+	import java.util.concurrent.CompletionService;
14	+	import java.util.concurrent.CountDownLatch;
15	+	import java.util.concurrent.ExecutionException;
16		import java.util.concurrent.ExecutorCompletionService;
14	–	import java.util.concurrent.Executors;
17		import java.util.concurrent.ExecutorService;
18		import java.util.concurrent.Future;
19		import java.util.concurrent.FutureTask;
#	Line 25 | Line 27 | import junit.framework.TestSuite;
27
28		public class ExecutorCompletionServiceTest extends JSR166TestCase {
29		public static void main(String[] args) {
30	<	junit.textui.TestRunner.run(suite());
30	>	main(suite(), args);
31		}
32		public static Test suite() {
33		return new TestSuite(ExecutorCompletionServiceTest.class);
34		}
35
36		/**
37	<	* Creating a new ECS with null Executor throw NPE
37	>	* new ExecutorCompletionService(null) throws NullPointerException
38		*/
39		public void testConstructorNPE() {
40		try {
#	Line 42 | Line 44 | public class ExecutorCompletionServiceTe
44		}
45
46		/**
47	<	* Creating a new ECS with null queue throw NPE
47	>	* new ExecutorCompletionService(e, null) throws NullPointerException
48		*/
49		public void testConstructorNPE2() {
50		try {
51	<	ExecutorService e = Executors.newCachedThreadPool();
50	<	new ExecutorCompletionService(e, null);
51	>	new ExecutorCompletionService(cachedThreadPool, null);
52		shouldThrow();
53		} catch (NullPointerException success) {}
54		}
55
56		/**
57	<	* Submitting a null callable throws NPE
57	>	* ecs.submit(null) throws NullPointerException
58		*/
59	<	public void testSubmitNPE() {
60	<	ExecutorService e = Executors.newCachedThreadPool();
60	<	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
59	>	public void testSubmitNullCallable() {
60	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
61		try {
62	<	Callable c = null;
63	<	ecs.submit(c);
62	>	cs.submit((Callable) null);
63		shouldThrow();
64	<	} catch (NullPointerException success) {
66	<	} finally {
67	<	joinPool(e);
68	<	}
64	>	} catch (NullPointerException success) {}
65		}
66
67		/**
68	<	* Submitting a null runnable throws NPE
68	>	* ecs.submit(null, val) throws NullPointerException
69		*/
70	<	public void testSubmitNPE2() {
71	<	ExecutorService e = Executors.newCachedThreadPool();
76	<	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
70	>	public void testSubmitNullRunnable() {
71	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
72		try {
73	<	Runnable r = null;
79	<	ecs.submit(r, Boolean.TRUE);
73	>	cs.submit((Runnable) null, Boolean.TRUE);
74		shouldThrow();
75	<	} catch (NullPointerException success) {
82	<	} finally {
83	<	joinPool(e);
84	<	}
75	>	} catch (NullPointerException success) {}
76		}
77
78		/**
79		* A taken submitted task is completed
80		*/
81	<	public void testTake() throws InterruptedException {
82	<	ExecutorService e = Executors.newCachedThreadPool();
83	<	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
84	<	try {
85	<	Callable c = new StringTask();
86	<	ecs.submit(c);
87	<	Future f = ecs.take();
97	<	assertTrue(f.isDone());
98	<	} finally {
99	<	joinPool(e);
100	<	}
81	>	public void testTake()
82	>	throws InterruptedException, ExecutionException {
83	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
84	>	cs.submit(new StringTask());
85	>	Future f = cs.take();
86	>	assertTrue(f.isDone());
87	>	assertSame(TEST_STRING, f.get());
88		}
89
90		/**
91		* Take returns the same future object returned by submit
92		*/
93		public void testTake2() throws InterruptedException {
94	<	ExecutorService e = Executors.newCachedThreadPool();
95	<	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
96	<	try {
97	<	Callable c = new StringTask();
98	<	Future f1 = ecs.submit(c);
99	<	Future f2 = ecs.take();
100	<	assertSame(f1, f2);
101	<	} finally {
102	<	joinPool(e);
103	<	}
104	<	}
105	<
106	<	/**
107	<	* If poll returns non-null, the returned task is completed
108	<	*/
109	<	public void testPoll1() throws Exception {
110	<	ExecutorService e = Executors.newCachedThreadPool();
111	<	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
112	<	try {
113	<	assertNull(ecs.poll());
114	<	Callable c = new StringTask();
115	<	ecs.submit(c);
116	<
117	<	long startTime = System.nanoTime();
118	<	Future f;
119	<	while ((f = ecs.poll()) == null) {
120	<	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
121	<	fail("timed out");
122	<	Thread.yield();
94	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
95	>	Future f1 = cs.submit(new StringTask());
96	>	Future f2 = cs.take();
97	>	assertSame(f1, f2);
98	>	}
99	>
100	>	/**
101	>	* poll returns non-null when the returned task is completed
102	>	*/
103	>	public void testPoll1()
104	>	throws InterruptedException, ExecutionException {
105	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
106	>	assertNull(cs.poll());
107	>	cs.submit(new StringTask());
108	>
109	>	long startTime = System.nanoTime();
110	>	Future f;
111	>	while ((f = cs.poll()) == null) {
112	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
113	>	fail("timed out");
114	>	Thread.yield();
115	>	}
116	>	assertTrue(f.isDone());
117	>	assertSame(TEST_STRING, f.get());
118	>	}
119	>
120	>	/**
121	>	* timed poll returns non-null when the returned task is completed
122	>	*/
123	>	public void testPoll2()
124	>	throws InterruptedException, ExecutionException {
125	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
126	>	assertNull(cs.poll());
127	>	cs.submit(new StringTask());
128	>
129	>	long startTime = System.nanoTime();
130	>	Future f;
131	>	while ((f = cs.poll(SHORT_DELAY_MS, MILLISECONDS)) == null) {
132	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
133	>	fail("timed out");
134	>	Thread.yield();
135	>	}
136	>	assertTrue(f.isDone());
137	>	assertSame(TEST_STRING, f.get());
138	>	}
139	>
140	>	/**
141	>	* poll returns null before the returned task is completed
142	>	*/
143	>	public void testPollReturnsNull()
144	>	throws InterruptedException, ExecutionException {
145	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
146	>	final CountDownLatch proceed = new CountDownLatch(1);
147	>	cs.submit(new Callable() { public String call() throws Exception {
148	>	await(proceed);
149	>	return TEST_STRING;
150	>	}});
151	>	assertNull(cs.poll());
152	>	assertNull(cs.poll(0L, MILLISECONDS));
153	>	assertNull(cs.poll(Long.MIN_VALUE, MILLISECONDS));
154	>	long startTime = System.nanoTime();
155	>	assertNull(cs.poll(timeoutMillis(), MILLISECONDS));
156	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
157	>	proceed.countDown();
158	>	assertSame(TEST_STRING, cs.take().get());
159	>	}
160	>
161	>	/**
162	>	* successful and failed tasks are both returned
163	>	*/
164	>	public void testTaskAssortment()
165	>	throws InterruptedException, ExecutionException {
166	>	CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
167	>	ArithmeticException ex = new ArithmeticException();
168	>	for (int i = 0; i < 2; i++) {
169	>	cs.submit(new StringTask());
170	>	cs.submit(callableThrowing(ex));
171	>	cs.submit(runnableThrowing(ex), null);
172	>	}
173	>	int normalCompletions = 0;
174	>	int exceptionalCompletions = 0;
175	>	for (int i = 0; i < 3 * 2; i++) {
176	>	try {
177	>	if (cs.take().get() == TEST_STRING)
178	>	normalCompletions++;
179	>	}
180	>	catch (ExecutionException expected) {
181	>	assertTrue(expected.getCause() instanceof ArithmeticException);
182	>	exceptionalCompletions++;
183		}
137	–	assertTrue(f.isDone());
138	–	assertSame(TEST_STRING, f.get());
139	–	} finally {
140	–	joinPool(e);
141	–	}
142	–	}
143	–
144	–	/**
145	–	* If timed poll returns non-null, the returned task is completed
146	–	*/
147	–	public void testPoll2() throws InterruptedException {
148	–	ExecutorService e = Executors.newCachedThreadPool();
149	–	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
150	–	try {
151	–	assertNull(ecs.poll());
152	–	Callable c = new StringTask();
153	–	ecs.submit(c);
154	–	Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
155	–	if (f != null)
156	–	assertTrue(f.isDone());
157	–	} finally {
158	–	joinPool(e);
184		}
185	+	assertEquals(2 * 1, normalCompletions);
186	+	assertEquals(2 * 2, exceptionalCompletions);
187	+	assertNull(cs.poll());
188		}
189
190		/**
#	Line 167 | Line 195 | public class ExecutorCompletionServiceTe
195		final AtomicBoolean done = new AtomicBoolean(false);
196		class MyCallableFuture<V> extends FutureTask<V> {
197		MyCallableFuture(Callable<V> c) { super(c); }
198	<	protected void done() { done.set(true); }
198	>	@Override protected void done() { done.set(true); }
199		}
200	<	ExecutorService e = new ThreadPoolExecutor(
201	<	1, 1, 30L, TimeUnit.SECONDS,
202	<	new ArrayBlockingQueue<Runnable>(1)) {
203	<	protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
204	<	return new MyCallableFuture<T>(c);
205	<	}};
206	<	ExecutorCompletionService<String> ecs =
207	<	new ExecutorCompletionService<String>(e);
208	<	try {
209	<	assertNull(ecs.poll());
200	>	final ExecutorService e =
201	>	new ThreadPoolExecutor(1, 1,
202	>	30L, TimeUnit.SECONDS,
203	>	new ArrayBlockingQueue<Runnable>(1)) {
204	>	protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
205	>	return new MyCallableFuture<T>(c);
206	>	}};
207	>	CompletionService<String> cs = new ExecutorCompletionService<>(e);
208	>	try (PoolCleaner cleaner = cleaner(e)) {
209	>	assertNull(cs.poll());
210		Callable<String> c = new StringTask();
211	<	Future f1 = ecs.submit(c);
211	>	Future f1 = cs.submit(c);
212		assertTrue("submit must return MyCallableFuture",
213		f1 instanceof MyCallableFuture);
214	<	Future f2 = ecs.take();
214	>	Future f2 = cs.take();
215		assertSame("submit and take must return same objects", f1, f2);
216		assertTrue("completed task must have set done", done.get());
189	–	} finally {
190	–	joinPool(e);
217		}
218		}
219
#	Line 199 | Line 225 | public class ExecutorCompletionServiceTe
225		final AtomicBoolean done = new AtomicBoolean(false);
226		class MyRunnableFuture<V> extends FutureTask<V> {
227		MyRunnableFuture(Runnable t, V r) { super(t, r); }
228	<	protected void done() { done.set(true); }
228	>	@Override protected void done() { done.set(true); }
229		}
230	<	ExecutorService e = new ThreadPoolExecutor(
231	<	1, 1, 30L, TimeUnit.SECONDS,
232	<	new ArrayBlockingQueue<Runnable>(1)) {
233	<	protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
234	<	return new MyRunnableFuture<T>(t, r);
235	<	}};
236	<	ExecutorCompletionService<String> ecs =
237	<	new ExecutorCompletionService<String>(e);
238	<	try {
239	<	assertNull(ecs.poll());
230	>	final ExecutorService e =
231	>	new ThreadPoolExecutor(1, 1,
232	>	30L, TimeUnit.SECONDS,
233	>	new ArrayBlockingQueue<Runnable>(1)) {
234	>	protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
235	>	return new MyRunnableFuture<T>(t, r);
236	>	}};
237	>	CompletionService<String> cs = new ExecutorCompletionService<>(e);
238	>	try (PoolCleaner cleaner = cleaner(e)) {
239	>	assertNull(cs.poll());
240		Runnable r = new NoOpRunnable();
241	<	Future f1 = ecs.submit(r, null);
241	>	Future f1 = cs.submit(r, null);
242		assertTrue("submit must return MyRunnableFuture",
243		f1 instanceof MyRunnableFuture);
244	<	Future f2 = ecs.take();
244	>	Future f2 = cs.take();
245		assertSame("submit and take must return same objects", f1, f2);
246		assertTrue("completed task must have set done", done.get());
221	–	} finally {
222	–	joinPool(e);
247		}
248		}
249

Diff Legend

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