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.11 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.12 by jsr166, Wed Aug 25 01:44:48 2010 UTC

#	Line 149 | Line 149 | public class ExecutorCompletionServiceTe
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(
152	>
153	>	/**
154	>	* Submitting to underlying AES that overrides newTaskFor(Callable)
155	>	* returns and eventually runs Future returned by newTaskFor.
156	>	*/
157	>	public void testNewTaskForCallable() throws InterruptedException {
158	>	final AtomicBoolean done = new AtomicBoolean(false);
159	>	class MyCallableFuture<V> extends FutureTask<V> {
160	>	MyCallableFuture(Callable<V> c) { super(c); }
161	>	protected void done() { done.set(true); }
162	>	}
163	>	ExecutorService e = new ThreadPoolExecutor(
164		1, 1, 30L, TimeUnit.SECONDS,
165		new ArrayBlockingQueue<Runnable>(1)) {
166	<	protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
167	<	return new MyCallableFuture<T>(c);
168	<	}
169	<	};
170	<	ExecutorCompletionService<String> ecs =
171	<	new ExecutorCompletionService<String>(e);
172	<	try {
173	<	assertNull(ecs.poll());
174	<	Callable<String> c = new StringTask();
175	<	Future f1 = ecs.submit(c);
176	<	assertTrue("submit must return MyCallableFuture",
177	<	f1 instanceof MyCallableFuture);
178	<	Future f2 = ecs.take();
179	<	assertSame("submit and take must return same objects", f1, f2);
180	<	assertTrue("completed task must have set done", done.get());
181	<	} finally {
182	<	joinPool(e);
183	<	}
183	<	}
166	>	protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
167	>	return new MyCallableFuture<T>(c);
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(
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	<	}
198	>	protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
199	>	return new MyRunnableFuture<T>(t, r);
200	>	}};
201	>	ExecutorCompletionService<String> ecs =
202	>	new ExecutorCompletionService<String>(e);
203	>	try {
204	>	assertNull(ecs.poll());
205	>	Runnable r = new NoOpRunnable();
206	>	Future f1 = ecs.submit(r, null);
207	>	assertTrue("submit must return MyRunnableFuture",
208	>	f1 instanceof MyRunnableFuture);
209	>	Future f2 = ecs.take();
210	>	assertSame("submit and take must return same objects", f1, f2);
211	>	assertTrue("completed task must have set done", done.get());
212	>	} finally {
213	>	joinPool(e);
214	>	}
215	>	}
216
217		}

Diff Legend

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