test/tck/FutureTaskTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes, 
 * Pat Fisher, Mike Judd. 
 */

import junit.framework.*;
import java.util.concurrent.*;
import java.util.*;

public class FutureTaskTest extends JSR166TestCase {

    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    public static Test suite() {
        return new TestSuite(FutureTaskTest.class);
    }

    /**
     * Subclass to expose protected methods
     */
    static class PublicFutureTask extends FutureTask {
        public PublicFutureTask(Callable r) { super(r); }
        public boolean runAndReset() { return super.runAndReset(); }
        public void set(Object x) { super.set(x); }
        public void setException(Throwable t) { super.setException(t); }
    }

    /**
     * Creating a future with a null callable throws NPE
     */
    public void testConstructor() {
        try {
            FutureTask task = new FutureTask(null);
            shouldThrow();
        }
        catch(NullPointerException success) {
        }
    }

    /**
     * creating a future with null runnable fails
     */
    public void testConstructor2() {
        try {
            FutureTask task = new FutureTask(null, Boolean.TRUE);
            shouldThrow();
        }
        catch(NullPointerException success) {
        }
    }

    /**
     * isDone is true when a task completes
     */
    public void testIsDone() {
        FutureTask task = new FutureTask( new NoOpCallable());
        task.run();
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

    /**
     * runAndReset of a non-cancelled task succeeds
     */
    public void testRunAndReset() {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        assertTrue(task.runAndReset());
        assertFalse(task.isDone());
    }

    /**
     * runAndReset after cancellation fails
     */
    public void testResetAfterCancel() {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        assertTrue(task.cancel(false));
        assertFalse(task.runAndReset());
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }


    /**
     * setting value gauses get to return it
     */
    public void testSet() {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        task.set(one);
        try {
            assertEquals(task.get(), one);
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     * setException causes get to throw ExecutionException
     */
    public void testSetException() {
        Exception nse = new NoSuchElementException();
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        task.setException(nse);
        try {
            Object x = task.get();
            shouldThrow();
        }
        catch(ExecutionException ee) {
            Throwable cause = ee.getCause();
            assertEquals(cause, nse);
        }
        catch(Exception e) {
            unexpectedException();
        }
    }

    /**
     *  Cancelling before running succeeds
     */
    public void testCancelBeforeRun() {
        FutureTask task = new FutureTask( new NoOpCallable());
        assertTrue(task.cancel(false));
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    /**
     * Cancel(true) before run succeeds
     */
    public void testCancelBeforeRun2() {
        FutureTask task = new FutureTask( new NoOpCallable());
        assertTrue(task.cancel(true));
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    /**
     * cancel of a completed task fails
     */
    public void testCancelAfterRun() {
        FutureTask task = new FutureTask( new NoOpCallable());
        task.run();
        assertFalse(task.cancel(false));
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

    /**
     * cancel(true) interrupts a running task
     */
    public void testCancelInterrupt() {
        FutureTask task = new FutureTask( new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(MEDIUM_DELAY_MS);
                        threadShouldThrow();
                    }
                    catch (InterruptedException success) {}
                    return Boolean.TRUE;
                } });
        Thread t = new  Thread(task);
        t.start();
        
        try {
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(task.cancel(true));
            t.join();
            assertTrue(task.isDone());
            assertTrue(task.isCancelled());
        } catch(InterruptedException e){
            unexpectedException();
        }
    }


    /**
     * cancel(false) does not interrupt a running task
     */
    public void testCancelNoInterrupt() {
        FutureTask task = new FutureTask( new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(MEDIUM_DELAY_MS);
                    }
                    catch (InterruptedException success) {
                        threadFail("should not interrupt");
                    }
                    return Boolean.TRUE;
                } });
        Thread t = new  Thread(task);
        t.start();
        
        try {
            Thread.sleep(SHORT_DELAY_MS);
            assertTrue(task.cancel(false));
            t.join();
            assertTrue(task.isDone());
            assertTrue(task.isCancelled());
        } catch(InterruptedException e){
            unexpectedException();
        }
    }

    /**
     * set in one thread causes get in another thread to retrieve value
     */
    public void testGet1() {
        final FutureTask ft = new FutureTask(new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(MEDIUM_DELAY_MS);
                    } catch(InterruptedException e){
                        threadUnexpectedException();
                    }
                    return Boolean.TRUE;
                }
        });
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        ft.get();
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            assertFalse(ft.isDone());
            assertFalse(ft.isCancelled());
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            ft.run();
            t.join();
            assertTrue(ft.isDone());
            assertFalse(ft.isCancelled());
        } catch(InterruptedException e){
            unexpectedException();

        }       
    }

    /**
     * set in one thread causes timed get in another thread to retrieve value
     */
    public void testTimedGet1() {
        final FutureTask ft = new FutureTask(new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(MEDIUM_DELAY_MS);
                    } catch(InterruptedException e){
                        threadUnexpectedException();
                    }
                    return Boolean.TRUE;
                }
            });
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                    } catch(TimeoutException success) {
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            assertFalse(ft.isDone());
            assertFalse(ft.isCancelled());
            t.start();
            ft.run();
            t.join();
            assertTrue(ft.isDone());
            assertFalse(ft.isCancelled());
        } catch(InterruptedException e){
            unexpectedException();
            
        }       
    }

    /**
     *  Cancelling a task causes timed get in another thread to throw CancellationException
     */
    public void testTimedGet_Cancellation() {
        final FutureTask ft = new FutureTask(new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(SMALL_DELAY_MS);
                        threadShouldThrow();
                    } catch(InterruptedException e) {
                    }
                    return Boolean.TRUE;
                }
            });
        try {
            Thread t1 = new Thread(new Runnable() {
                    public void run() {
                        try {
                            ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
                            threadShouldThrow();
                        } catch(CancellationException success) {}
                        catch(Exception e){
                            threadUnexpectedException();
                        }
                    }
                });
            Thread t2 = new Thread(ft);
            t1.start(); 
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            ft.cancel(true);
            t1.join();
            t2.join();
        } catch(InterruptedException ie){
            unexpectedException();
        }
    }

    /**
     * Cancelling a task causes get in another thread to throw CancellationException
     */
    public void testGet_Cancellation() {
        final FutureTask ft = new FutureTask(new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(MEDIUM_DELAY_MS);
                        threadShouldThrow();
                    } catch(InterruptedException e){
                    }
                    return Boolean.TRUE;
                }
            });
        try {
            Thread t1 = new Thread(new Runnable() {
                    public void run() {
                        try {
                            ft.get();
                            threadShouldThrow();
                        } catch(CancellationException success){
                        }
                        catch(Exception e){
                            threadUnexpectedException();
                        }
                    }
                });
            Thread t2 = new Thread(ft);
            t1.start(); 
            t2.start();
            Thread.sleep(SHORT_DELAY_MS);
            ft.cancel(true);
            t1.join();
            t2.join();
        } catch(InterruptedException success){
            unexpectedException();
        }
    }
    

    /**
     * A runtime exception in task causes get to throw ExecutionException
     */
    public void testGet_ExecutionException() {
        final FutureTask ft = new FutureTask(new Callable() {
                public Object call() {
                    int i = 5/0;
                    return Boolean.TRUE;
                }
            });
        try {
            ft.run();
            ft.get();
            shouldThrow();
        } catch(ExecutionException success){
        }
        catch(Exception e){
            unexpectedException();
        }
    }
  
    /**
     *  A runtime exception in task causes timed get to throw ExecutionException
     */
    public void testTimedGet_ExecutionException2() {
        final FutureTask ft = new FutureTask(new Callable() {
                public Object call() {
                    int i = 5/0;
                    return Boolean.TRUE;
                }
            });
        try {
            ft.run();
            ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
            shouldThrow();
        } catch(ExecutionException success) { 
        } catch(TimeoutException success) { } // unlikely but OK
        catch(Exception e){
            unexpectedException();
        }
    }
      

    /**
     * Interrupting a waiting get causes it to throw InterruptedException
     */
    public void testGet_InterruptedException() {
        final FutureTask ft = new FutureTask(new NoOpCallable());
        Thread t = new Thread(new Runnable() {
                public void run() {                 
                    try {
                        ft.get();
                        threadShouldThrow();
                    } catch(InterruptedException success){
                    } catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    }

    /**
     *  Interrupting a waiting timed get causes it to throw InterruptedException
     */
    public void testTimedGet_InterruptedException2() {
        final FutureTask ft = new FutureTask(new NoOpCallable());
        Thread t = new Thread(new Runnable() {
                public void run() {                 
                    try {
                        ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
                        threadShouldThrow();
                    } catch(InterruptedException success){}
                    catch(Exception e){
                        threadUnexpectedException();
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e){
            unexpectedException();
        }
    }
    
    /**
     * A timed out timed get throws TimeoutException
     */
    public void testGet_TimeoutException() {
        try {
            FutureTask ft = new FutureTask(new NoOpCallable());
            ft.get(1,TimeUnit.MILLISECONDS);
            shouldThrow();
        } catch(TimeoutException success){}
        catch(Exception success){
            unexpectedException();
        }
    }
    
}
Revision:	1.10
Committed:	Sat Dec 27 19:26:43 2003 UTC (20 years, 4 months ago) by dl
Branch:	MAIN
Changes since 1.9:	+5 -4 lines
Log Message:	Headers reference Creative Commons
#	Content
1	/*
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 java.util.*;
12
13	public class FutureTaskTest extends JSR166TestCase {
14
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18	public static Test suite() {
19	return new TestSuite(FutureTaskTest.class);
20	}
21
22	/**
23	* Subclass to expose protected methods
24	*/
25	static class PublicFutureTask extends FutureTask {
26	public PublicFutureTask(Callable r) { super(r); }
27	public boolean runAndReset() { return super.runAndReset(); }
28	public void set(Object x) { super.set(x); }
29	public void setException(Throwable t) { super.setException(t); }
30	}
31
32	/**
33	* Creating a future with a null callable throws NPE
34	*/
35	public void testConstructor() {
36	try {
37	FutureTask task = new FutureTask(null);
38	shouldThrow();
39	}
40	catch(NullPointerException success) {
41	}
42	}
43
44	/**
45	* creating a future with null runnable fails
46	*/
47	public void testConstructor2() {
48	try {
49	FutureTask task = new FutureTask(null, Boolean.TRUE);
50	shouldThrow();
51	}
52	catch(NullPointerException success) {
53	}
54	}
55
56	/**
57	* isDone is true when a task completes
58	*/
59	public void testIsDone() {
60	FutureTask task = new FutureTask( new NoOpCallable());
61	task.run();
62	assertTrue(task.isDone());
63	assertFalse(task.isCancelled());
64	}
65
66	/**
67	* runAndReset of a non-cancelled task succeeds
68	*/
69	public void testRunAndReset() {
70	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
71	assertTrue(task.runAndReset());
72	assertFalse(task.isDone());
73	}
74
75	/**
76	* runAndReset after cancellation fails
77	*/
78	public void testResetAfterCancel() {
79	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
80	assertTrue(task.cancel(false));
81	assertFalse(task.runAndReset());
82	assertTrue(task.isDone());
83	assertTrue(task.isCancelled());
84	}
85
86
87
88	/**
89	* setting value gauses get to return it
90	*/
91	public void testSet() {
92	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
93	task.set(one);
94	try {
95	assertEquals(task.get(), one);
96	}
97	catch(Exception e) {
98	unexpectedException();
99	}
100	}
101
102	/**
103	* setException causes get to throw ExecutionException
104	*/
105	public void testSetException() {
106	Exception nse = new NoSuchElementException();
107	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
108	task.setException(nse);
109	try {
110	Object x = task.get();
111	shouldThrow();
112	}
113	catch(ExecutionException ee) {
114	Throwable cause = ee.getCause();
115	assertEquals(cause, nse);
116	}
117	catch(Exception e) {
118	unexpectedException();
119	}
120	}
121
122	/**
123	* Cancelling before running succeeds
124	*/
125	public void testCancelBeforeRun() {
126	FutureTask task = new FutureTask( new NoOpCallable());
127	assertTrue(task.cancel(false));
128	task.run();
129	assertTrue(task.isDone());
130	assertTrue(task.isCancelled());
131	}
132
133	/**
134	* Cancel(true) before run succeeds
135	*/
136	public void testCancelBeforeRun2() {
137	FutureTask task = new FutureTask( new NoOpCallable());
138	assertTrue(task.cancel(true));
139	task.run();
140	assertTrue(task.isDone());
141	assertTrue(task.isCancelled());
142	}
143
144	/**
145	* cancel of a completed task fails
146	*/
147	public void testCancelAfterRun() {
148	FutureTask task = new FutureTask( new NoOpCallable());
149	task.run();
150	assertFalse(task.cancel(false));
151	assertTrue(task.isDone());
152	assertFalse(task.isCancelled());
153	}
154
155	/**
156	* cancel(true) interrupts a running task
157	*/
158	public void testCancelInterrupt() {
159	FutureTask task = new FutureTask( new Callable() {
160	public Object call() {
161	try {
162	Thread.sleep(MEDIUM_DELAY_MS);
163	threadShouldThrow();
164	}
165	catch (InterruptedException success) {}
166	return Boolean.TRUE;
167	} });
168	Thread t = new Thread(task);
169	t.start();
170
171	try {
172	Thread.sleep(SHORT_DELAY_MS);
173	assertTrue(task.cancel(true));
174	t.join();
175	assertTrue(task.isDone());
176	assertTrue(task.isCancelled());
177	} catch(InterruptedException e){
178	unexpectedException();
179	}
180	}
181
182
183	/**
184	* cancel(false) does not interrupt a running task
185	*/
186	public void testCancelNoInterrupt() {
187	FutureTask task = new FutureTask( new Callable() {
188	public Object call() {
189	try {
190	Thread.sleep(MEDIUM_DELAY_MS);
191	}
192	catch (InterruptedException success) {
193	threadFail("should not interrupt");
194	}
195	return Boolean.TRUE;
196	} });
197	Thread t = new Thread(task);
198	t.start();
199
200	try {
201	Thread.sleep(SHORT_DELAY_MS);
202	assertTrue(task.cancel(false));
203	t.join();
204	assertTrue(task.isDone());
205	assertTrue(task.isCancelled());
206	} catch(InterruptedException e){
207	unexpectedException();
208	}
209	}
210
211	/**
212	* set in one thread causes get in another thread to retrieve value
213	*/
214	public void testGet1() {
215	final FutureTask ft = new FutureTask(new Callable() {
216	public Object call() {
217	try {
218	Thread.sleep(MEDIUM_DELAY_MS);
219	} catch(InterruptedException e){
220	threadUnexpectedException();
221	}
222	return Boolean.TRUE;
223	}
224	});
225	Thread t = new Thread(new Runnable() {
226	public void run() {
227	try {
228	ft.get();
229	} catch(Exception e){
230	threadUnexpectedException();
231	}
232	}
233	});
234	try {
235	assertFalse(ft.isDone());
236	assertFalse(ft.isCancelled());
237	t.start();
238	Thread.sleep(SHORT_DELAY_MS);
239	ft.run();
240	t.join();
241	assertTrue(ft.isDone());
242	assertFalse(ft.isCancelled());
243	} catch(InterruptedException e){
244	unexpectedException();
245
246	}
247	}
248
249	/**
250	* set in one thread causes timed get in another thread to retrieve value
251	*/
252	public void testTimedGet1() {
253	final FutureTask ft = new FutureTask(new Callable() {
254	public Object call() {
255	try {
256	Thread.sleep(MEDIUM_DELAY_MS);
257	} catch(InterruptedException e){
258	threadUnexpectedException();
259	}
260	return Boolean.TRUE;
261	}
262	});
263	Thread t = new Thread(new Runnable() {
264	public void run() {
265	try {
266	ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
267	} catch(TimeoutException success) {
268	} catch(Exception e){
269	threadUnexpectedException();
270	}
271	}
272	});
273	try {
274	assertFalse(ft.isDone());
275	assertFalse(ft.isCancelled());
276	t.start();
277	ft.run();
278	t.join();
279	assertTrue(ft.isDone());
280	assertFalse(ft.isCancelled());
281	} catch(InterruptedException e){
282	unexpectedException();
283
284	}
285	}
286
287	/**
288	* Cancelling a task causes timed get in another thread to throw CancellationException
289	*/
290	public void testTimedGet_Cancellation() {
291	final FutureTask ft = new FutureTask(new Callable() {
292	public Object call() {
293	try {
294	Thread.sleep(SMALL_DELAY_MS);
295	threadShouldThrow();
296	} catch(InterruptedException e) {
297	}
298	return Boolean.TRUE;
299	}
300	});
301	try {
302	Thread t1 = new Thread(new Runnable() {
303	public void run() {
304	try {
305	ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
306	threadShouldThrow();
307	} catch(CancellationException success) {}
308	catch(Exception e){
309	threadUnexpectedException();
310	}
311	}
312	});
313	Thread t2 = new Thread(ft);
314	t1.start();
315	t2.start();
316	Thread.sleep(SHORT_DELAY_MS);
317	ft.cancel(true);
318	t1.join();
319	t2.join();
320	} catch(InterruptedException ie){
321	unexpectedException();
322	}
323	}
324
325	/**
326	* Cancelling a task causes get in another thread to throw CancellationException
327	*/
328	public void testGet_Cancellation() {
329	final FutureTask ft = new FutureTask(new Callable() {
330	public Object call() {
331	try {
332	Thread.sleep(MEDIUM_DELAY_MS);
333	threadShouldThrow();
334	} catch(InterruptedException e){
335	}
336	return Boolean.TRUE;
337	}
338	});
339	try {
340	Thread t1 = new Thread(new Runnable() {
341	public void run() {
342	try {
343	ft.get();
344	threadShouldThrow();
345	} catch(CancellationException success){
346	}
347	catch(Exception e){
348	threadUnexpectedException();
349	}
350	}
351	});
352	Thread t2 = new Thread(ft);
353	t1.start();
354	t2.start();
355	Thread.sleep(SHORT_DELAY_MS);
356	ft.cancel(true);
357	t1.join();
358	t2.join();
359	} catch(InterruptedException success){
360	unexpectedException();
361	}
362	}
363
364
365	/**
366	* A runtime exception in task causes get to throw ExecutionException
367	*/
368	public void testGet_ExecutionException() {
369	final FutureTask ft = new FutureTask(new Callable() {
370	public Object call() {
371	int i = 5/0;
372	return Boolean.TRUE;
373	}
374	});
375	try {
376	ft.run();
377	ft.get();
378	shouldThrow();
379	} catch(ExecutionException success){
380	}
381	catch(Exception e){
382	unexpectedException();
383	}
384	}
385
386	/**
387	* A runtime exception in task causes timed get to throw ExecutionException
388	*/
389	public void testTimedGet_ExecutionException2() {
390	final FutureTask ft = new FutureTask(new Callable() {
391	public Object call() {
392	int i = 5/0;
393	return Boolean.TRUE;
394	}
395	});
396	try {
397	ft.run();
398	ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
399	shouldThrow();
400	} catch(ExecutionException success) {
401	} catch(TimeoutException success) { } // unlikely but OK
402	catch(Exception e){
403	unexpectedException();
404	}
405	}
406
407
408	/**
409	* Interrupting a waiting get causes it to throw InterruptedException
410	*/
411	public void testGet_InterruptedException() {
412	final FutureTask ft = new FutureTask(new NoOpCallable());
413	Thread t = new Thread(new Runnable() {
414	public void run() {
415	try {
416	ft.get();
417	threadShouldThrow();
418	} catch(InterruptedException success){
419	} catch(Exception e){
420	threadUnexpectedException();
421	}
422	}
423	});
424	try {
425	t.start();
426	Thread.sleep(SHORT_DELAY_MS);
427	t.interrupt();
428	t.join();
429	} catch(Exception e){
430	unexpectedException();
431	}
432	}
433
434	/**
435	* Interrupting a waiting timed get causes it to throw InterruptedException
436	*/
437	public void testTimedGet_InterruptedException2() {
438	final FutureTask ft = new FutureTask(new NoOpCallable());
439	Thread t = new Thread(new Runnable() {
440	public void run() {
441	try {
442	ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
443	threadShouldThrow();
444	} catch(InterruptedException success){}
445	catch(Exception e){
446	threadUnexpectedException();
447	}
448	}
449	});
450	try {
451	t.start();
452	Thread.sleep(SHORT_DELAY_MS);
453	t.interrupt();
454	t.join();
455	} catch(Exception e){
456	unexpectedException();
457	}
458	}
459
460	/**
461	* A timed out timed get throws TimeoutException
462	*/
463	public void testGet_TimeoutException() {
464	try {
465	FutureTask ft = new FutureTask(new NoOpCallable());
466	ft.get(1,TimeUnit.MILLISECONDS);
467	shouldThrow();
468	} catch(TimeoutException success){}
469	catch(Exception success){
470	unexpectedException();
471	}
472	}
473
474	}