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.3 by dl, Fri Sep 12 15:40:25 2003 UTC vs.
Revision 1.21 by jsr166, Sat Oct 9 19:30:35 2010 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 testConstructor(){
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	<	fail("should throw");
40	<	}
29	<	catch(NullPointerException success) {
30	<	}
39	>	shouldThrow();
40	>	} catch (NullPointerException success) {}
41		}
42
43	<	public void testConstructor2(){
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	<	fail("should throw");
50	<	}
51	<	catch(NullPointerException success) {
52	<	}
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	<	public void testIsDone(){
84	<	FutureTask task = new FutureTask( new Callable() {
85	<	public Object call() { return Boolean.TRUE; } });
86	<	task.run();
87	<	assertTrue(task.isDone());
88	<	assertFalse(task.isCancelled());
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() {
52	<	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() {
61	<	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; } });
71	<	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();
94	<	assertTrue(task.isDone());
95	<	assertTrue(task.isCancelled());
96	<	} catch(InterruptedException e){
97	<	fail("unexpected exception");
98	<	}
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");
110	<	}
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();
120	<	assertTrue(task.isDone());
121	<	assertTrue(task.isCancelled());
122	<	} catch(InterruptedException e){
123	<	fail("unexpected exception");
124	<	}
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");
134	<	}
135	<	return Boolean.TRUE;
136	<	}
137	<	});
138	<	Thread t = new Thread(new Runnable(){
139	<	public void run(){
140	<	try{
141	<	ft.get();
142	<	} catch(Exception e){
143	<	fail("unexpected exception");
144	<	}
145	<	}
146	<	});
147	<	try{
148	<	assertFalse(ft.isDone());
149	<	assertFalse(ft.isCancelled());
150	<	t.start();
151	<	Thread.sleep(SHORT_DELAY_MS);
152	<	ft.run();
153	<	t.join();
154	<	assertTrue(ft.isDone());
155	<	assertFalse(ft.isCancelled());
156	<	} catch(InterruptedException e){
157	<	fail("unexpected exception");
158	<
159	<	}
160	<	}
161	<
162	<	public void testTimedGet1() {
163	<	final FutureTask ft = new FutureTask(new Callable(){
164	<	public Object call(){
165	<	try{
166	<	Thread.sleep(MEDIUM_DELAY_MS);
167	<	} catch(InterruptedException e){
168	<	fail("unexpected exception");
169	<	}
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(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
197	<	} catch(TimeoutException success) {
198	<	} catch(Exception e){
199	<	fail("unexpected exception");
200	<	}
201	<	}
202	<	});
203	<	try{
204	<	assertFalse(ft.isDone());
185	<	assertFalse(ft.isCancelled());
186	<	t.start();
187	<	ft.run();
188	<	t.join();
189	<	assertTrue(ft.isDone());
190	<	assertFalse(ft.isCancelled());
191	<	} catch(InterruptedException e){
192	<	fail("unexpected exception");
193	<
194	<	}
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	+	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	<	public void testGet_Cancellation(){
222	<	final FutureTask ft = new FutureTask(new Callable(){
223	<	public Object call(){
224	<	try{
225	<	Thread.sleep(MEDIUM_DELAY_MS);
226	<	} catch(InterruptedException e){
227	<	fail("unexpected exception");
228	<	}
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
233	>	* CancellationException
234	>	*/
235	>	public void testTimedGet_Cancellation() throws InterruptedException {
236	>	final FutureTask ft =
237	>	new FutureTask(new CheckedInterruptedCallable<Object>() {
238	>	public Object realCall() throws InterruptedException {
239	>	Thread.sleep(SMALL_DELAY_MS);
240		return Boolean.TRUE;
241	<	}
242	<	});
243	<	try {
244	<	Thread.sleep(SHORT_DELAY_MS);
245	<	Thread t = new Thread(new Runnable(){
246	<	public void run(){
247	<	try{
248	<	ft.get();
249	<	fail("should throw");
250	<	} catch(CancellationException success){
251	<	}
252	<	catch(Exception e){
253	<	fail("unexpected exception");
254	<	}
255	<	}
256	<	});
257	<	t.start();
258	<	ft.cancel(true);
259	<	t.join();
260	<	} catch(InterruptedException success){
261	<	fail("unexpected exception");
262	<	}
263	<	}
264	<
265	<	public void testGet_Cancellation2(){
266	<	final FutureTask ft = new FutureTask(new Callable(){
267	<	public Object call(){
268	<	try{
269	<	Thread.sleep(SHORT_DELAY_MS);
270	<	} catch(InterruptedException e) {
271	<	fail("unexpected exception");
272	<	}
273	<	return Boolean.TRUE;
274	<	}
275	<	});
276	<	try{
277	<	Thread.sleep(100);
278	<	Thread t = new Thread(new Runnable(){
245	<	public void run(){
246	<	try{
247	<	ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
248	<	fail("should throw");
249	<	} catch(CancellationException success) {}
250	<	catch(Exception e){
251	<	fail("unexpected exception");
252	<	}
253	<	}
254	<	});
255	<	t.start();
256	<	Thread.sleep(SHORT_DELAY_MS);
257	<	ft.cancel(true);
258	<	Thread.sleep(SHORT_DELAY_MS);
259	<	t.join();
260	<	} catch(InterruptedException ie){
261	<	fail("unexpected exception");
262	<	}
241	>	}});
242	>
243	>	Thread t1 = new ThreadShouldThrow(CancellationException.class) {
244	>	public void realRun() throws Exception {
245	>	ft.get(MEDIUM_DELAY_MS, MILLISECONDS);
246	>	}};
247	>	Thread t2 = new Thread(ft);
248	>	t1.start();
249	>	t2.start();
250	>	Thread.sleep(SHORT_DELAY_MS);
251	>	ft.cancel(true);
252	>	t1.join();
253	>	t2.join();
254	>	}
255	>
256	>	/**
257	>	* Cancelling a task causes get in another thread to throw
258	>	* CancellationException
259	>	*/
260	>	public void testGet_Cancellation() throws InterruptedException {
261	>	final FutureTask ft =
262	>	new FutureTask(new CheckedInterruptedCallable<Object>() {
263	>	public Object realCall() throws InterruptedException {
264	>	Thread.sleep(SMALL_DELAY_MS);
265	>	return Boolean.TRUE;
266	>	}});
267	>	Thread t1 = new ThreadShouldThrow(CancellationException.class) {
268	>	public void realRun() throws Exception {
269	>	ft.get();
270	>	}};
271	>
272	>	Thread t2 = new Thread(ft);
273	>	t1.start();
274	>	t2.start();
275	>	Thread.sleep(SHORT_DELAY_MS);
276	>	ft.cancel(true);
277	>	t1.join();
278	>	t2.join();
279		}
280
281	<	public void testGet_ExecutionException(){
282	<	final FutureTask ft = new FutureTask(new Callable(){
283	<	public Object call(){
284	<	int i = 5/0;
285	<	return Boolean.TRUE;
286	<	}
287	<	});
288	<	try{
289	<	ft.run();
290	<	ft.get();
291	<	fail("should throw");
276	<	} catch(ExecutionException success){
277	<	}
278	<	catch(Exception e){
279	<	fail("unexpected exception");
280	<	}
281	<	}
282	<
283	<	public void testTimedGet_ExecutionException2(){
284	<	final FutureTask ft = new FutureTask(new Callable(){
285	<	public Object call(){
286	<	int i = 5/0;
287	<	return Boolean.TRUE;
288	<	}
289	<	});
290	<	try{
291	<	ft.run();
292	<	ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
293	<	fail("should throw");
294	<	} catch(ExecutionException success) {
295	<	} catch(TimeoutException success) { } // unlikely but OK
296	<	catch(Exception e){
297	<	fail("unexpected exception");
298	<	}
299	<	}
300	<
301	<
302	<	public void testGet_InterruptedException(){
303	<	final FutureTask ft = new FutureTask(new Callable(){
304	<	public Object call(){
305	<	return new Object();
306	<	}
307	<	});
308	<	Thread t = new Thread(new Runnable(){
309	<	public void run(){
310	<	try{
311	<	ft.get();
312	<	fail("should throw");
313	<	} catch(InterruptedException success){
314	<	} catch(Exception e){
315	<	fail("unexpected exception");
316	<	}
317	<	}
318	<	});
281	>
282	>	/**
283	>	* A runtime exception in task causes get to throw ExecutionException
284	>	*/
285	>	public void testGet_ExecutionException() throws InterruptedException {
286	>	final FutureTask ft = new FutureTask(new Callable() {
287	>	public Object call() {
288	>	return 5/0;
289	>	}});
290	>
291	>	ft.run();
292		try {
293	<	t.start();
294	<	Thread.sleep(SHORT_DELAY_MS);
295	<	t.interrupt();
296	<	t.join();
324	<	} catch(Exception e){
325	<	fail("unexpected exception");
293	>	ft.get();
294	>	shouldThrow();
295	>	} catch (ExecutionException success) {
296	>	assertTrue(success.getCause() instanceof ArithmeticException);
297		}
298		}
299
300	<	public void testTimedGet_InterruptedException2(){
301	<	final FutureTask ft = new FutureTask(new Callable(){
302	<	public Object call(){
303	<	return new Object();
304	<	}
305	<	});
306	<	Thread t = new Thread(new Runnable(){
307	<	public void run(){
308	<	try{
309	<	ft.get(100,TimeUnit.SECONDS);
339	<	fail("should throw");
340	<	} catch(InterruptedException success){}
341	<	catch(Exception e){
342	<	fail("unexpected exception");
343	<	}
344	<	}
345	<	});
300	>	/**
301	>	* A runtime exception in task causes timed get to throw ExecutionException
302	>	*/
303	>	public void testTimedGet_ExecutionException2() throws Exception {
304	>	final FutureTask ft = new FutureTask(new Callable() {
305	>	public Object call() {
306	>	return 5/0;
307	>	}});
308	>
309	>	ft.run();
310		try {
311	<	t.start();
312	<	Thread.sleep(SHORT_DELAY_MS);
313	<	t.interrupt();
314	<	t.join();
351	<	} catch(Exception e){
352	<	fail("unexpected exception");
311	>	ft.get(SHORT_DELAY_MS, MILLISECONDS);
312	>	shouldThrow();
313	>	} catch (ExecutionException success) {
314	>	assertTrue(success.getCause() instanceof ArithmeticException);
315		}
316		}
317	<
318	<	public void testGet_TimeoutException(){
319	<	FutureTask ft = new FutureTask(new Callable(){
320	<	public Object call(){
321	<	return new Object();
322	<	}
323	<	});
324	<	try{
325	<	ft.get(1,TimeUnit.MILLISECONDS);
326	<	fail("should throw");
327	<	} catch(TimeoutException success){}
328	<	catch(Exception success){
329	<	fail("unexpected exception");
330	<	}
331	<
332	<
317	>
318	>
319	>	/**
320	>	* Interrupting a waiting get causes it to throw InterruptedException
321	>	*/
322	>	public void testGet_InterruptedException() throws InterruptedException {
323	>	final FutureTask ft = new FutureTask(new NoOpCallable());
324	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
325	>	public void realRun() throws Exception {
326	>	ft.get();
327	>	}});
328	>
329	>	t.start();
330	>	Thread.sleep(SHORT_DELAY_MS);
331	>	t.interrupt();
332	>	t.join();
333		}
334	<
334	>
335	>	/**
336	>	* Interrupting a waiting timed get causes it to throw InterruptedException
337	>	*/
338	>	public void testTimedGet_InterruptedException2() throws InterruptedException {
339	>	final FutureTask ft = new FutureTask(new NoOpCallable());
340	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
341	>	public void realRun() throws Exception {
342	>	ft.get(LONG_DELAY_MS,MILLISECONDS);
343	>	}});
344	>
345	>	t.start();
346	>	Thread.sleep(SHORT_DELAY_MS);
347	>	t.interrupt();
348	>	t.join();
349	>	}
350	>
351	>	/**
352	>	* A timed out timed get throws TimeoutException
353	>	*/
354	>	public void testGet_TimeoutException() throws Exception {
355	>	try {
356	>	FutureTask ft = new FutureTask(new NoOpCallable());
357	>	ft.get(1,MILLISECONDS);
358	>	shouldThrow();
359	>	} catch (TimeoutException success) {}
360	>	}
361	>
362		}

Diff Legend

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