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.1 by dl, Tue Dec 23 19:40:24 2003 UTC vs.
Revision 1.10 by jsr166, Sat Nov 21 06:31:05 2009 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
2	>	* Written by Doug Lea with assistance from members of JCP JSR-166
3	>	* Expert Group and released to the public domain, as explained at
4	>	* http://creativecommons.org/licenses/publicdomain
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
9
10		import junit.framework.*;
11		import java.util.*;
12		import java.util.concurrent.*;
13	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14	+	import java.util.concurrent.atomic.*;
15		import java.math.BigInteger;
16		import java.security.*;
17
18	<	public class ExecutorCompletionServiceTest extends JSR166TestCase{
18	>	public class ExecutorCompletionServiceTest extends JSR166TestCase {
19		public static void main(String[] args) {
20	<	junit.textui.TestRunner.run (suite());
20	>	junit.textui.TestRunner.run (suite());
21		}
22		public static Test suite() {
23		return new TestSuite(ExecutorCompletionServiceTest.class);
#	Line 23 | Line 26 | public class ExecutorCompletionServiceTe
26
27		/**
28		* Creating a new ECS with null Executor throw NPE
29	<	*/
29	>	*/
30		public void testConstructorNPE() {
31		try {
32		ExecutorCompletionService ecs = new ExecutorCompletionService(null);
33		shouldThrow();
34	<	} catch (NullPointerException success) {
32	<	}
34	>	} catch (NullPointerException success) {}
35		}
36
37		/**
38		* Creating a new ECS with null queue throw NPE
39	<	*/
39	>	*/
40		public void testConstructorNPE2() {
41		try {
42		ExecutorService e = Executors.newCachedThreadPool();
43		ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
44		shouldThrow();
45	<	} catch (NullPointerException success) {
44	<	}
45	>	} catch (NullPointerException success) {}
46		}
47
48		/**
49		* Submitting a null callable throws NPE
50	<	*/
50	>	*/
51		public void testSubmitNPE() {
52		ExecutorService e = Executors.newCachedThreadPool();
53		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
#	Line 62 | Line 63 | public class ExecutorCompletionServiceTe
63
64		/**
65		* Submitting a null runnable throws NPE
66	<	*/
66	>	*/
67		public void testSubmitNPE2() {
68		ExecutorService e = Executors.newCachedThreadPool();
69		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
#	Line 78 | Line 79 | public class ExecutorCompletionServiceTe
79
80		/**
81		* A taken submitted task is completed
82	<	*/
83	<	public void testTake() {
82	>	*/
83	>	public void testTake() throws InterruptedException {
84		ExecutorService e = Executors.newCachedThreadPool();
85		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
86		try {
87		Callable c = new StringTask();
88		ecs.submit(c);
89		Future f = ecs.take();
90	<	assert(f.isDone());
90	<	} catch (Exception ex) {
91	<	unexpectedException();
90	>	assertTrue(f.isDone());
91		} finally {
92		joinPool(e);
93		}
#	Line 96 | Line 95 | public class ExecutorCompletionServiceTe
95
96		/**
97		* Take returns the same future object returned by submit
98	<	*/
99	<	public void testTake2() {
98	>	*/
99	>	public void testTake2() throws InterruptedException {
100		ExecutorService e = Executors.newCachedThreadPool();
101		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
102		try {
#	Line 105 | Line 104 | public class ExecutorCompletionServiceTe
104		Future f1 = ecs.submit(c);
105		Future f2 = ecs.take();
106		assertSame(f1, f2);
108	–	} catch (Exception ex) {
109	–	unexpectedException();
107		} finally {
108		joinPool(e);
109		}
#	Line 114 | Line 111 | public class ExecutorCompletionServiceTe
111
112		/**
113		* If poll returns non-null, the returned task is completed
114	<	*/
115	<	public void testPoll1() {
114	>	*/
115	>	public void testPoll1() throws InterruptedException {
116		ExecutorService e = Executors.newCachedThreadPool();
117		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
118		try {
#	Line 126 | Line 123 | public class ExecutorCompletionServiceTe
123		for (;;) {
124		Future f = ecs.poll();
125		if (f != null) {
126	<	assert(f.isDone());
126	>	assertTrue(f.isDone());
127		break;
128		}
129		}
133	–	} catch (Exception ex) {
134	–	unexpectedException();
130		} finally {
131		joinPool(e);
132		}
#	Line 139 | Line 134 | public class ExecutorCompletionServiceTe
134
135		/**
136		* If timed poll returns non-null, the returned task is completed
137	<	*/
138	<	public void testPoll2() {
137	>	*/
138	>	public void testPoll2() throws InterruptedException {
139		ExecutorService e = Executors.newCachedThreadPool();
140		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
141		try {
142		assertNull(ecs.poll());
143		Callable c = new StringTask();
144		ecs.submit(c);
145	<	Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
146	<	if (f != null)
147	<	assert(f.isDone());
148	<	} catch (Exception ex) {
149	<	unexpectedException();
150	<	} finally {
151	<	joinPool(e);
152	<	}
153	<	}
145	>	Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
146	>	if (f != null)
147	>	assertTrue(f.isDone());
148	>	} finally {
149	>	joinPool(e);
150	>	}
151	>	}
152	>	/**
153	>	* Submitting to underlying AES that overrides newTaskFor(Callable)
154	>	* returns and eventually runs Future returned by newTaskFor.
155	>	*/
156	>	public void testNewTaskForCallable() throws InterruptedException {
157	>	final AtomicBoolean done = new AtomicBoolean(false);
158	>	class MyCallableFuture<V> extends FutureTask<V> {
159	>	MyCallableFuture(Callable<V> c) { super(c); }
160	>	protected void done() { done.set(true); }
161	>	}
162	>	ExecutorService e = new ThreadPoolExecutor(
163	>	1, 1, 30L, TimeUnit.SECONDS,
164	>	new ArrayBlockingQueue<Runnable>(1)) {
165	>	protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
166	>	return new MyCallableFuture<T>(c);
167	>	}
168	>	};
169	>	ExecutorCompletionService<String> ecs =
170	>	new ExecutorCompletionService<String>(e);
171	>	try {
172	>	assertNull(ecs.poll());
173	>	Callable<String> c = new StringTask();
174	>	Future f1 = ecs.submit(c);
175	>	assertTrue("submit must return MyCallableFuture",
176	>	f1 instanceof MyCallableFuture);
177	>	Future f2 = ecs.take();
178	>	assertSame("submit and take must return same objects", f1, f2);
179	>	assertTrue("completed task must have set done", done.get());
180	>	} finally {
181	>	joinPool(e);
182	>	}
183	>	}
184	>
185	>	/**
186	>	* Submitting to underlying AES that overrides newTaskFor(Runnable,T)
187	>	* returns and eventually runs Future returned by newTaskFor.
188	>	*/
189	>	public void testNewTaskForRunnable() throws InterruptedException {
190	>	final AtomicBoolean done = new AtomicBoolean(false);
191	>	class MyRunnableFuture<V> extends FutureTask<V> {
192	>	MyRunnableFuture(Runnable t, V r) { super(t, r); }
193	>	protected void done() { done.set(true); }
194	>	}
195	>	ExecutorService e = new ThreadPoolExecutor(
196	>	1, 1, 30L, TimeUnit.SECONDS,
197	>	new ArrayBlockingQueue<Runnable>(1)) {
198	>	protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
199	>	return new MyRunnableFuture<T>(t, r);
200	>	}
201	>	};
202	>	ExecutorCompletionService<String> ecs =
203	>	new ExecutorCompletionService<String>(e);
204	>	try {
205	>	assertNull(ecs.poll());
206	>	Runnable r = new NoOpRunnable();
207	>	Future f1 = ecs.submit(r, null);
208	>	assertTrue("submit must return MyRunnableFuture",
209	>	f1 instanceof MyRunnableFuture);
210	>	Future f2 = ecs.take();
211	>	assertSame("submit and take must return same objects", f1, f2);
212	>	assertTrue("completed task must have set done", done.get());
213	>	} finally {
214	>	joinPool(e);
215	>	}
216	>	}
217
218		}

Diff Legend

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