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 static java.util.concurrent.TimeUnit.MILLISECONDS;
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 causes get to return it
     */
    public void testSet() throws Exception {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        task.set(one);
        assertSame(task.get(), one);
    }

    /**
     * setException causes get to throw ExecutionException
     */
    public void testSetException() throws Exception {
        Exception nse = new NoSuchElementException();
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        task.setException(nse);
        try {
            Object x = task.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertSame(success.getCause(), nse);
        }
    }

    /**
     *  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() throws InterruptedException {
        final FutureTask task =
            new FutureTask(new CheckedInterruptedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    Thread.sleep(SMALL_DELAY_MS);
                    return Boolean.TRUE;
                }});

        Thread t = new Thread(task);
        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        assertTrue(task.cancel(true));
        t.join();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }


    /**
     * cancel(false) does not interrupt a running task
     */
    public void testCancelNoInterrupt() throws InterruptedException {
        final FutureTask task =
            new FutureTask(new CheckedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    Thread.sleep(MEDIUM_DELAY_MS);
                    return Boolean.TRUE;
                }});

        Thread t = new Thread(task);
        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        assertTrue(task.cancel(false));
        t.join();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    /**
     * set in one thread causes get in another thread to retrieve value
     */
    public void testGet1() throws InterruptedException {
        final FutureTask ft =
            new FutureTask(new CheckedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    return Boolean.TRUE;
                }});
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(Boolean.TRUE, ft.get());
            }});

        assertFalse(ft.isDone());
        assertFalse(ft.isCancelled());
        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        ft.run();
        t.join();
        assertTrue(ft.isDone());
        assertFalse(ft.isCancelled());
    }

    /**
     * set in one thread causes timed get in another thread to retrieve value
     */
    public void testTimedGet1() throws InterruptedException {
        final FutureTask ft =
            new FutureTask(new CheckedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    return Boolean.TRUE;
                }});
        Thread t = new Thread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(Boolean.TRUE, ft.get(SMALL_DELAY_MS, MILLISECONDS));
            }});

        assertFalse(ft.isDone());
        assertFalse(ft.isCancelled());
        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        ft.run();
        t.join();
        assertTrue(ft.isDone());
        assertFalse(ft.isCancelled());
    }

    /**
     *  Cancelling a task causes timed get in another thread to throw
     *  CancellationException
     */
    public void testTimedGet_Cancellation() throws InterruptedException {
        final FutureTask ft =
            new FutureTask(new CheckedInterruptedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    Thread.sleep(SMALL_DELAY_MS);
                    return Boolean.TRUE;
                }});

        Thread t1 = new ThreadShouldThrow(CancellationException.class) {
            public void realRun() throws Exception {
                ft.get(MEDIUM_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new Thread(ft);
        t1.start();
        t2.start();
        Thread.sleep(SHORT_DELAY_MS);
        ft.cancel(true);
        t1.join();
        t2.join();
    }

    /**
     * Cancelling a task causes get in another thread to throw
     * CancellationException
     */
    public void testGet_Cancellation() throws InterruptedException {
        final FutureTask ft =
            new FutureTask(new CheckedInterruptedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    Thread.sleep(SMALL_DELAY_MS);
                    return Boolean.TRUE;
                }});
        Thread t1 = new ThreadShouldThrow(CancellationException.class) {
            public void realRun() throws Exception {
                ft.get();
            }};

        Thread t2 = new Thread(ft);
        t1.start();
        t2.start();
        Thread.sleep(SHORT_DELAY_MS);
        ft.cancel(true);
        t1.join();
        t2.join();
    }


    /**
     * A runtime exception in task causes get to throw ExecutionException
     */
    public void testGet_ExecutionException() throws InterruptedException {
        final FutureTask ft = new FutureTask(new Callable() {
            public Object call() {
                return 5/0;
            }});

        ft.run();
        try {
            ft.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof ArithmeticException);
        }
    }

    /**
     * A runtime exception in task causes timed get to throw ExecutionException
     */
    public void testTimedGet_ExecutionException2() throws Exception {
        final FutureTask ft = new FutureTask(new Callable() {
            public Object call() {
                return 5/0;
            }});

        ft.run();
        try {
            ft.get(SHORT_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof ArithmeticException);
        }
    }


    /**
     * Interrupting a waiting get causes it to throw InterruptedException
     */
    public void testGet_InterruptedException() throws InterruptedException {
        final FutureTask ft = new FutureTask(new NoOpCallable());
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                ft.get();
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        t.join();
    }

    /**
     * Interrupting a waiting timed get causes it to throw InterruptedException
     */
    public void testTimedGet_InterruptedException2() throws InterruptedException {
        final FutureTask ft = new FutureTask(new NoOpCallable());
        Thread t = new Thread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                ft.get(LONG_DELAY_MS,MILLISECONDS);
            }});

        t.start();
        Thread.sleep(SHORT_DELAY_MS);
        t.interrupt();
        t.join();
    }

    /**
     * A timed out timed get throws TimeoutException
     */
    public void testGet_TimeoutException() throws Exception {
        try {
            FutureTask ft = new FutureTask(new NoOpCallable());
            ft.get(1,MILLISECONDS);
            shouldThrow();
        } catch (TimeoutException success) {}
    }

}
Revision:	1.20
Committed:	Thu Sep 16 00:52:49 2010 UTC (13 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.19:	+6 -4 lines
Log Message:	testcase hygiene: introduce CheckedRecursiveAction and CheckedRecursiveTask; eliminate almost all threadAssertXXX; use preferred junit conventions;narrow the scope of exception checking code; make sure test failures in non-junit threads produce proper stacktraces
#	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 static java.util.concurrent.TimeUnit.MILLISECONDS;
12	import java.util.*;
13
14	public class FutureTaskTest extends JSR166TestCase {
15
16	public static void main(String[] args) {
17	junit.textui.TestRunner.run(suite());
18	}
19	public static Test suite() {
20	return new TestSuite(FutureTaskTest.class);
21	}
22
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 NoOpCallable());
114	assertTrue(task.cancel(false));
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 NoOpCallable());
125	assertTrue(task.cancel(true));
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 NoOpCallable());
136	task.run();
137	assertFalse(task.cancel(false));
138	assertTrue(task.isDone());
139	assertFalse(task.isCancelled());
140	}
141
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
153	Thread t = new Thread(task);
154	t.start();
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	/**
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
174	Thread t = new Thread(task);
175	t.start();
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	/**
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	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	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	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
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	ft.get();
294	shouldThrow();
295	} catch (ExecutionException success) {
296	assertTrue(success.getCause() instanceof ArithmeticException);
297	}
298	}
299
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	ft.get(SHORT_DELAY_MS, MILLISECONDS);
312	shouldThrow();
313	} catch (ExecutionException success) {
314	assertTrue(success.getCause() instanceof ArithmeticException);
315	}
316	}
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
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	}