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.19
Committed:	Wed Aug 25 00:07:03 2010 UTC (13 years, 8 months ago) by jsr166
Branch:	MAIN
Changes since 1.18:	+1 -1 lines
Log Message:	whitespace
#	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 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	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	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
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	ft.get();
292	shouldThrow();
293	} catch (ExecutionException success) {
294	assertTrue(success.getCause() instanceof ArithmeticException);
295	}
296	}
297
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	ft.get(SHORT_DELAY_MS, MILLISECONDS);
310	shouldThrow();
311	} catch (ExecutionException success) {
312	assertTrue(success.getCause() instanceof ArithmeticException);
313	}
314	}
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
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	}