ViewVC Help

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

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

Comparing jsr166/src/test/tck/FutureTaskTest.java (file contents):
Revision 1.1 by dl, Sun Aug 31 19:24:55 2003 UTC vs.
Revision 1.18 by jsr166, Tue Dec 1 09:56:28 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		import junit.framework.*;
10		import java.util.concurrent.*;
11	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
12	+	import java.util.*;
13
14	<	public class FutureTaskTest extends TestCase {
14	>	public class FutureTaskTest extends JSR166TestCase {
15
16		public static void main(String[] args) {
17	<	junit.textui.TestRunner.run (suite());
17	>	junit.textui.TestRunner.run (suite());
18		}
19		public static Test suite() {
20	<	return new TestSuite(FutureTaskTest.class);
20	>	return new TestSuite(FutureTaskTest.class);
21		}
22
23	<	private static long SHORT_DELAY_MS = 100;
24	<	private static long MEDIUM_DELAY_MS = 1000;
25	<	private static long LONG_DELAY_MS = 10000;
26	<
27	<	public void testIsDone(){
28	<	FutureTask task = new FutureTask( new Callable() {
29	<	public Object call() { return Boolean.TRUE; } });
30	<	task.run();
31	<	assertTrue(task.isDone());
32	<	assertFalse(task.isCancelled());
23	>	/**
24	>	* Subclass to expose protected methods
25	>	*/
26	>	static class PublicFutureTask extends FutureTask {
27	>	public PublicFutureTask(Callable r) { super(r); }
28	>	public boolean runAndReset() { return super.runAndReset(); }
29	>	public void set(Object x) { super.set(x); }
30	>	public void setException(Throwable t) { super.setException(t); }
31	>	}
32	>
33	>	/**
34	>	* Creating a future with a null callable throws NPE
35	>	*/
36	>	public void testConstructor() {
37	>	try {
38	>	FutureTask task = new FutureTask(null);
39	>	shouldThrow();
40	>	} catch (NullPointerException success) {}
41	>	}
42	>
43	>	/**
44	>	* creating a future with null runnable fails
45	>	*/
46	>	public void testConstructor2() {
47	>	try {
48	>	FutureTask task = new FutureTask(null, Boolean.TRUE);
49	>	shouldThrow();
50	>	} catch (NullPointerException success) {}
51	>	}
52	>
53	>	/**
54	>	* isDone is true when a task completes
55	>	*/
56	>	public void testIsDone() {
57	>	FutureTask task = new FutureTask(new NoOpCallable());
58	>	task.run();
59	>	assertTrue(task.isDone());
60	>	assertFalse(task.isCancelled());
61	>	}
62	>
63	>	/**
64	>	* runAndReset of a non-cancelled task succeeds
65	>	*/
66	>	public void testRunAndReset() {
67	>	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
68	>	assertTrue(task.runAndReset());
69	>	assertFalse(task.isDone());
70	>	}
71	>
72	>	/**
73	>	* runAndReset after cancellation fails
74	>	*/
75	>	public void testResetAfterCancel() {
76	>	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
77	>	assertTrue(task.cancel(false));
78	>	assertFalse(task.runAndReset());
79	>	assertTrue(task.isDone());
80	>	assertTrue(task.isCancelled());
81	>	}
82	>
83	>
84	>
85	>	/**
86	>	* setting value causes get to return it
87	>	*/
88	>	public void testSet() throws Exception {
89	>	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
90	>	task.set(one);
91	>	assertSame(task.get(), one);
92		}
93
94	+	/**
95	+	* setException causes get to throw ExecutionException
96	+	*/
97	+	public void testSetException() throws Exception {
98	+	Exception nse = new NoSuchElementException();
99	+	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
100	+	task.setException(nse);
101	+	try {
102	+	Object x = task.get();
103	+	shouldThrow();
104	+	} catch (ExecutionException success) {
105	+	assertSame(success.getCause(), nse);
106	+	}
107	+	}
108	+
109	+	/**
110	+	*  Cancelling before running succeeds
111	+	*/
112		public void testCancelBeforeRun() {
113	<	FutureTask task = new FutureTask( new Callable() {
34	<	public Object call() { return Boolean.TRUE; } });
113	>	FutureTask task = new FutureTask(new NoOpCallable());
114		assertTrue(task.cancel(false));
115	<	task.run();
116	<	assertTrue(task.isDone());
117	<	assertTrue(task.isCancelled());
115	>	task.run();
116	>	assertTrue(task.isDone());
117	>	assertTrue(task.isCancelled());
118		}
119
120	+	/**
121	+	* Cancel(true) before run succeeds
122	+	*/
123		public void testCancelBeforeRun2() {
124	<	FutureTask task = new FutureTask( new Callable() {
43	<	public Object call() { return Boolean.TRUE; } });
124	>	FutureTask task = new FutureTask(new NoOpCallable());
125		assertTrue(task.cancel(true));
126	<	task.run();
127	<	assertTrue(task.isDone());
128	<	assertTrue(task.isCancelled());
126	>	task.run();
127	>	assertTrue(task.isDone());
128	>	assertTrue(task.isCancelled());
129		}
130
131	+	/**
132	+	* cancel of a completed task fails
133	+	*/
134		public void testCancelAfterRun() {
135	<	FutureTask task = new FutureTask( new Callable() {
136	<	public Object call() { return Boolean.TRUE; } });
53	<	task.run();
135	>	FutureTask task = new FutureTask(new NoOpCallable());
136	>	task.run();
137		assertFalse(task.cancel(false));
138	<	assertTrue(task.isDone());
139	<	assertFalse(task.isCancelled());
138	>	assertTrue(task.isDone());
139	>	assertFalse(task.isCancelled());
140		}
141
142	<	public void testCancelInterrupt(){
143	<	FutureTask task = new FutureTask( new Callable() {
144	<	public Object call() {
145	<	try {
146	<	Thread.sleep(SHORT_DELAY_MS* 2);
147	<	fail("should throw");
148	<	}
149	<	catch (InterruptedException success) {}
142	>	/**
143	>	* cancel(true) interrupts a running task
144	>	*/
145	>	public void testCancelInterrupt() throws InterruptedException {
146	>	final FutureTask task =
147	>	new FutureTask(new CheckedInterruptedCallable<Object>() {
148	>	public Object realCall() throws InterruptedException {
149	>	Thread.sleep(SMALL_DELAY_MS);
150		return Boolean.TRUE;
151	<	} });
152	<	Thread t = new  Thread(task);
151	>	}});
152	>
153	>	Thread t = new Thread(task);
154		t.start();
155	<
156	<	try{
157	<	Thread.sleep(SHORT_DELAY_MS);
158	<	assertTrue(task.cancel(true));
159	<	t.join();
76	<	assertTrue(task.isDone());
77	<	assertTrue(task.isCancelled());
78	<	} catch(InterruptedException e){
79	<	fail("unexpected exception");
80	<	}
155	>	Thread.sleep(SHORT_DELAY_MS);
156	>	assertTrue(task.cancel(true));
157	>	t.join();
158	>	assertTrue(task.isDone());
159	>	assertTrue(task.isCancelled());
160		}
161
162
163	<	public void testCancelNoInterrupt(){
164	<	FutureTask task = new FutureTask( new Callable() {
165	<	public Object call() {
166	<	try {
167	<	Thread.sleep(SHORT_DELAY_MS* 2);
168	<	}
169	<	catch (InterruptedException success) {
170	<	fail("should not interrupt");
92	<	}
163	>	/**
164	>	* cancel(false) does not interrupt a running task
165	>	*/
166	>	public void testCancelNoInterrupt() throws InterruptedException {
167	>	final FutureTask task =
168	>	new FutureTask(new CheckedCallable<Object>() {
169	>	public Object realCall() throws InterruptedException {
170	>	Thread.sleep(MEDIUM_DELAY_MS);
171		return Boolean.TRUE;
172	<	} });
173	<	Thread t = new  Thread(task);
172	>	}});
173	>
174	>	Thread t = new Thread(task);
175		t.start();
176	<
177	<	try{
178	<	Thread.sleep(SHORT_DELAY_MS);
179	<	assertTrue(task.cancel(false));
180	<	t.join();
102	<	assertTrue(task.isDone());
103	<	assertTrue(task.isCancelled());
104	<	} catch(InterruptedException e){
105	<	fail("unexpected exception");
106	<	}
176	>	Thread.sleep(SHORT_DELAY_MS);
177	>	assertTrue(task.cancel(false));
178	>	t.join();
179	>	assertTrue(task.isDone());
180	>	assertTrue(task.isCancelled());
181		}
182
183	<	public void testGet1() {
184	<	final FutureTask ft = new FutureTask(new Callable(){
185	<	public Object call(){
186	<	try{
187	<	Thread.sleep(MEDIUM_DELAY_MS);
188	<	}catch(InterruptedException e){
189	<	fail("unexpected exception");
116	<	}
183	>	/**
184	>	* set in one thread causes get in another thread to retrieve value
185	>	*/
186	>	public void testGet1() throws InterruptedException {
187	>	final FutureTask ft =
188	>	new FutureTask(new CheckedCallable<Object>() {
189	>	public Object realCall() throws InterruptedException {
190		return Boolean.TRUE;
191	<	}
192	<	});
193	<	Thread t = new Thread(new Runnable(){
194	<	public void run(){
195	<	try{
196	<	ft.get();
197	<	}catch(Exception e){
198	<	fail("unexpected exception");
199	<	}
200	<	}
201	<	});
202	<	try{
203	<	assertFalse(ft.isDone());
204	<	assertFalse(ft.isCancelled());
205	<	t.start();
206	<	Thread.sleep(SHORT_DELAY_MS);
207	<	ft.run();
208	<	t.join();
209	<	assertTrue(ft.isDone());
210	<	assertFalse(ft.isCancelled());
211	<	} catch(InterruptedException e){
212	<	fail("unexpected exception");
213	<
141	<	}
142	<	}
143	<
144	<	public void testTimedGet1() {
145	<	final FutureTask ft = new FutureTask(new Callable(){
146	<	public Object call(){
147	<	try{
148	<	Thread.sleep(MEDIUM_DELAY_MS);
149	<	}catch(InterruptedException e){
150	<	fail("unexpected exception");
151	<	}
191	>	}});
192	>	Thread t = new Thread(new CheckedRunnable() {
193	>	public void realRun() throws Exception {
194	>	assertSame(Boolean.TRUE, ft.get());
195	>	}});
196	>
197	>	assertFalse(ft.isDone());
198	>	assertFalse(ft.isCancelled());
199	>	t.start();
200	>	Thread.sleep(SHORT_DELAY_MS);
201	>	ft.run();
202	>	t.join();
203	>	assertTrue(ft.isDone());
204	>	assertFalse(ft.isCancelled());
205	>	}
206	>
207	>	/**
208	>	* set in one thread causes timed get in another thread to retrieve value
209	>	*/
210	>	public void testTimedGet1() throws InterruptedException {
211	>	final FutureTask ft =
212	>	new FutureTask(new CheckedCallable<Object>() {
213	>	public Object realCall() throws InterruptedException {
214		return Boolean.TRUE;
215	<	}
216	<	});
217	<	Thread t = new Thread(new Runnable(){
218	<	public void run(){
219	<	try{
220	<	ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
221	<	} catch(TimeoutException success) {
222	<	} catch(Exception e){
223	<	fail("unexpected exception");
224	<	}
225	<	}
226	<	});
227	<	try{
228	<	assertFalse(ft.isDone());
167	<	assertFalse(ft.isCancelled());
168	<	t.start();
169	<	ft.run();
170	<	t.join();
171	<	assertTrue(ft.isDone());
172	<	assertFalse(ft.isCancelled());
173	<	} catch(InterruptedException e){
174	<	fail("unexpected exception");
175	<
176	<	}
215	>	}});
216	>	Thread t = new Thread(new CheckedRunnable() {
217	>	public void realRun() throws Exception {
218	>	assertSame(Boolean.TRUE, ft.get(SMALL_DELAY_MS, MILLISECONDS));
219	>	}});
220	>
221	>	assertFalse(ft.isDone());
222	>	assertFalse(ft.isCancelled());
223	>	t.start();
224	>	Thread.sleep(SHORT_DELAY_MS);
225	>	ft.run();
226	>	t.join();
227	>	assertTrue(ft.isDone());
228	>	assertFalse(ft.isCancelled());
229		}
230
231	+	/**
232	+	*  Cancelling a task causes timed get in another thread to throw CancellationException
233	+	*/
234	+	public void testTimedGet_Cancellation() throws InterruptedException {
235	+	final FutureTask ft =
236	+	new FutureTask(new CheckedInterruptedCallable<Object>() {
237	+	public Object realCall() throws InterruptedException {
238	+	Thread.sleep(SMALL_DELAY_MS);
239	+	return Boolean.TRUE;
240	+	}});
241
242	<	public void testGet_Cancellation(){
243	<	final FutureTask ft = new FutureTask(new Callable(){
244	<	public Object call(){
245	<	try{
246	<	Thread.sleep(MEDIUM_DELAY_MS);
247	<	}catch(InterruptedException e){
248	<	fail("unexpected exception");
249	<	}
242	>	Thread t1 = new ThreadShouldThrow(CancellationException.class) {
243	>	public void realRun() throws Exception {
244	>	ft.get(MEDIUM_DELAY_MS, MILLISECONDS);
245	>	}};
246	>	Thread t2 = new Thread(ft);
247	>	t1.start();
248	>	t2.start();
249	>	Thread.sleep(SHORT_DELAY_MS);
250	>	ft.cancel(true);
251	>	t1.join();
252	>	t2.join();
253	>	}
254	>
255	>	/**
256	>	* Cancelling a task causes get in another thread to throw CancellationException
257	>	*/
258	>	public void testGet_Cancellation() throws InterruptedException {
259	>	final FutureTask ft =
260	>	new FutureTask(new CheckedInterruptedCallable<Object>() {
261	>	public Object realCall() throws InterruptedException {
262	>	Thread.sleep(SMALL_DELAY_MS);
263		return Boolean.TRUE;
264	<	}
265	<	});
266	<	try {
267	<	Thread.sleep(SHORT_DELAY_MS);
268	<	Thread t = new Thread(new Runnable(){
269	<	public void run(){
270	<	try{
271	<	ft.get();
272	<	fail("should throw");
273	<	}catch(CancellationException success){
274	<	}
275	<	catch(Exception e){
276	<	fail("unexpected exception");
202	<	}
203	<	}
204	<	});
205	<	t.start();
206	<	ft.cancel(true);
207	<	t.join();
208	<	}catch(InterruptedException sucess){
209	<	fail("unexpected exception");
210	<	}
211	<	}
212	<
213	<	public void testGet_Cancellation2(){
214	<	final FutureTask ft = new FutureTask(new Callable(){
215	<	public Object call(){
216	<	try{
217	<	Thread.sleep(SHORT_DELAY_MS);
218	<	} catch(InterruptedException e) {
219	<	fail("unexpected exception");
220	<	}
221	<	return Boolean.TRUE;
222	<	}
223	<	});
224	<	try{
225	<	Thread.sleep(100);
226	<	Thread t = new Thread(new Runnable(){
227	<	public void run(){
228	<	try{
229	<	ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
230	<	fail("should throw");
231	<	}catch(CancellationException success) {}
232	<	catch(Exception e){
233	<	fail("unexpected exception");
234	<	}
235	<	}
236	<	});
237	<	t.start();
238	<	Thread.sleep(SHORT_DELAY_MS);
239	<	ft.cancel(true);
240	<	Thread.sleep(SHORT_DELAY_MS);
241	<	t.join();
242	<	}catch(InterruptedException ie){
243	<	fail("unexpected exception");
244	<	}
264	>	}});
265	>	Thread t1 = new ThreadShouldThrow(CancellationException.class) {
266	>	public void realRun() throws Exception {
267	>	ft.get();
268	>	}};
269	>
270	>	Thread t2 = new Thread(ft);
271	>	t1.start();
272	>	t2.start();
273	>	Thread.sleep(SHORT_DELAY_MS);
274	>	ft.cancel(true);
275	>	t1.join();
276	>	t2.join();
277		}
278
279	<	public void testGet_ExecutionException(){
280	<	final FutureTask ft = new FutureTask(new Callable(){
281	<	public Object call(){
282	<	int i = 5/0;
283	<	return Boolean.TRUE;
284	<	}
285	<	});
286	<	try{
287	<	ft.run();
288	<	ft.get();
289	<	fail("should throw");
258	<	}catch(ExecutionException success){
259	<	}
260	<	catch(Exception e){
261	<	fail("unexpected exception");
262	<	}
263	<	}
264	<
265	<	public void testTimedGet_ExecutionException2(){
266	<	final FutureTask ft = new FutureTask(new Callable(){
267	<	public Object call(){
268	<	int i = 5/0;
269	<	return Boolean.TRUE;
270	<	}
271	<	});
272	<	try{
273	<	ft.run();
274	<	ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
275	<	fail("should throw");
276	<	}catch(ExecutionException success) {
277	<	}catch(TimeoutException success) { } // unlikely but OK
278	<	catch(Exception e){
279	<	fail("unexpected exception");
280	<	}
281	<	}
282	<
283	<
284	<	public void testGet_InterruptedException(){
285	<	final FutureTask ft = new FutureTask(new Callable(){
286	<	public Object call(){
287	<	return new Object();
288	<	}
289	<	});
290	<	Thread t = new Thread(new Runnable(){
291	<	public void run(){
292	<	try{
293	<	ft.get();
294	<	fail("should throw");
295	<	} catch(InterruptedException success){
296	<	} catch(Exception e){
297	<	fail("unexpected exception");
298	<	}
299	<	}
300	<	});
279	>
280	>	/**
281	>	* A runtime exception in task causes get to throw ExecutionException
282	>	*/
283	>	public void testGet_ExecutionException() throws InterruptedException {
284	>	final FutureTask ft = new FutureTask(new Callable() {
285	>	public Object call() {
286	>	return 5/0;
287	>	}});
288	>
289	>	ft.run();
290		try {
291	<	t.start();
292	<	Thread.sleep(SHORT_DELAY_MS);
293	<	t.interrupt();
294	<	t.join();
306	<	} catch(Exception e){
307	<	fail("unexpected exception");
291	>	ft.get();
292	>	shouldThrow();
293	>	} catch (ExecutionException success) {
294	>	assertTrue(success.getCause() instanceof ArithmeticException);
295		}
296		}
297
298	<	public void testTimedGet_InterruptedException2(){
299	<	final FutureTask ft = new FutureTask(new Callable(){
300	<	public Object call(){
301	<	return new Object();
302	<	}
303	<	});
304	<	Thread t = new Thread(new Runnable(){
305	<	public void run(){
306	<	try{
307	<	ft.get(100,TimeUnit.SECONDS);
321	<	fail("should throw");
322	<	}catch(InterruptedException success){}
323	<	catch(Exception e){
324	<	fail("unexpected exception");
325	<	}
326	<	}
327	<	});
298	>	/**
299	>	*  A runtime exception in task causes timed get to throw ExecutionException
300	>	*/
301	>	public void testTimedGet_ExecutionException2() throws Exception {
302	>	final FutureTask ft = new FutureTask(new Callable() {
303	>	public Object call() {
304	>	return 5/0;
305	>	}});
306	>
307	>	ft.run();
308		try {
309	<	t.start();
310	<	Thread.sleep(SHORT_DELAY_MS);
311	<	t.interrupt();
312	<	t.join();
333	<	} catch(Exception e){
334	<	fail("unexpected exception");
309	>	ft.get(SHORT_DELAY_MS, MILLISECONDS);
310	>	shouldThrow();
311	>	} catch (ExecutionException success) {
312	>	assertTrue(success.getCause() instanceof ArithmeticException);
313		}
314		}
315	<
316	<	public void testGet_TimeoutException(){
317	<	FutureTask ft = new FutureTask(new Callable(){
318	<	public Object call(){
319	<	return new Object();
320	<	}
321	<	});
322	<	try{
323	<	ft.get(1,TimeUnit.MILLISECONDS);
324	<	fail("should throw");
325	<	}catch(TimeoutException success){}
326	<	catch(Exception sucess){
327	<	fail("unexpected exception");
328	<	}
329	<
330	<
315	>
316	>
317	>	/**
318	>	* Interrupting a waiting get causes it to throw InterruptedException
319	>	*/
320	>	public void testGet_InterruptedException() throws InterruptedException {
321	>	final FutureTask ft = new FutureTask(new NoOpCallable());
322	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
323	>	public void realRun() throws Exception {
324	>	ft.get();
325	>	}});
326	>
327	>	t.start();
328	>	Thread.sleep(SHORT_DELAY_MS);
329	>	t.interrupt();
330	>	t.join();
331	>	}
332	>
333	>	/**
334	>	*  Interrupting a waiting timed get causes it to throw InterruptedException
335	>	*/
336	>	public void testTimedGet_InterruptedException2() throws InterruptedException {
337	>	final FutureTask ft = new FutureTask(new NoOpCallable());
338	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
339	>	public void realRun() throws Exception {
340	>	ft.get(LONG_DELAY_MS,MILLISECONDS);
341	>	}});
342	>
343	>	t.start();
344	>	Thread.sleep(SHORT_DELAY_MS);
345	>	t.interrupt();
346	>	t.join();
347		}
348	<
348	>
349	>	/**
350	>	* A timed out timed get throws TimeoutException
351	>	*/
352	>	public void testGet_TimeoutException() throws Exception {
353	>	try {
354	>	FutureTask ft = new FutureTask(new NoOpCallable());
355	>	ft.get(1,MILLISECONDS);
356	>	shouldThrow();
357	>	} catch (TimeoutException success) {}
358	>	}
359	>
360		}

Diff Legend

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