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
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.10	* 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	jsr166	1.12	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9			import junit.framework.*;
10			import java.util.concurrent.*;
11	jsr166	1.15	import static java.util.concurrent.TimeUnit.MILLISECONDS;
12	dl	1.4	import java.util.*;
13	dl	1.1
14	dl	1.4	public class FutureTaskTest extends JSR166TestCase {
15	dl	1.1
16			public static void main(String[] args) {
17	jsr166	1.19	junit.textui.TestRunner.run(suite());
18	dl	1.1	}
19			public static Test suite() {
20	jsr166	1.16	return new TestSuite(FutureTaskTest.class);
21	dl	1.1	}
22
23	dl	1.4	/**
24			* Subclass to expose protected methods
25			*/
26	dl	1.7	static class PublicFutureTask extends FutureTask {
27			public PublicFutureTask(Callable r) { super(r); }
28	dl	1.9	public boolean runAndReset() { return super.runAndReset(); }
29	dl	1.4	public void set(Object x) { super.set(x); }
30			public void setException(Throwable t) { super.setException(t); }
31			}
32	dl	1.1
33	dl	1.5	/**
34	dl	1.6	* Creating a future with a null callable throws NPE
35	dl	1.5	*/
36			public void testConstructor() {
37	dl	1.3	try {
38			FutureTask task = new FutureTask(null);
39	jsr166	1.17	shouldThrow();
40	jsr166	1.15	} catch (NullPointerException success) {}
41	dl	1.3	}
42
43	dl	1.5	/**
44	dl	1.6	* creating a future with null runnable fails
45	dl	1.5	*/
46			public void testConstructor2() {
47	dl	1.3	try {
48			FutureTask task = new FutureTask(null, Boolean.TRUE);
49	jsr166	1.17	shouldThrow();
50	jsr166	1.15	} catch (NullPointerException success) {}
51	dl	1.3	}
52
53	dl	1.5	/**
54	dl	1.6	* isDone is true when a task completes
55	dl	1.5	*/
56			public void testIsDone() {
57	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
58	jsr166	1.16	task.run();
59			assertTrue(task.isDone());
60			assertFalse(task.isCancelled());
61	dl	1.4	}
62
63	dl	1.5	/**
64	dl	1.9	* runAndReset of a non-cancelled task succeeds
65	dl	1.5	*/
66	dl	1.9	public void testRunAndReset() {
67	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
68	jsr166	1.16	assertTrue(task.runAndReset());
69	dl	1.6	assertFalse(task.isDone());
70	dl	1.4	}
71
72	dl	1.5	/**
73	dl	1.9	* runAndReset after cancellation fails
74	dl	1.5	*/
75	dl	1.4	public void testResetAfterCancel() {
76	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
77	dl	1.4	assertTrue(task.cancel(false));
78	jsr166	1.16	assertFalse(task.runAndReset());
79			assertTrue(task.isDone());
80			assertTrue(task.isCancelled());
81	dl	1.4	}
82
83	dl	1.1
84	dl	1.4
85	dl	1.5	/**
86	dl	1.11	* setting value causes get to return it
87	dl	1.5	*/
88	jsr166	1.15	public void testSet() throws Exception {
89	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
90	dl	1.4	task.set(one);
91	jsr166	1.18	assertSame(task.get(), one);
92	dl	1.4	}
93
94	dl	1.5	/**
95	dl	1.6	* setException causes get to throw ExecutionException
96	dl	1.5	*/
97	jsr166	1.15	public void testSetException() throws Exception {
98	dl	1.4	Exception nse = new NoSuchElementException();
99	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
100	dl	1.4	task.setException(nse);
101			try {
102			Object x = task.get();
103	jsr166	1.17	shouldThrow();
104	jsr166	1.15	} catch (ExecutionException success) {
105			assertSame(success.getCause(), nse);
106	dl	1.4	}
107			}
108
109	dl	1.5	/**
110	dl	1.6	* Cancelling before running succeeds
111	dl	1.5	*/
112	dl	1.1	public void testCancelBeforeRun() {
113	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
114	dl	1.1	assertTrue(task.cancel(false));
115	jsr166	1.16	task.run();
116			assertTrue(task.isDone());
117			assertTrue(task.isCancelled());
118	dl	1.1	}
119
120	dl	1.5	/**
121	dl	1.6	* Cancel(true) before run succeeds
122	dl	1.5	*/
123	dl	1.1	public void testCancelBeforeRun2() {
124	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
125	dl	1.1	assertTrue(task.cancel(true));
126	jsr166	1.16	task.run();
127			assertTrue(task.isDone());
128			assertTrue(task.isCancelled());
129	dl	1.1	}
130
131	dl	1.5	/**
132	dl	1.6	* cancel of a completed task fails
133	dl	1.5	*/
134	dl	1.1	public void testCancelAfterRun() {
135	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
136	jsr166	1.16	task.run();
137	dl	1.1	assertFalse(task.cancel(false));
138	jsr166	1.16	assertTrue(task.isDone());
139			assertFalse(task.isCancelled());
140	dl	1.1	}
141
142	dl	1.5	/**
143	dl	1.6	* cancel(true) interrupts a running task
144	dl	1.5	*/
145	jsr166	1.15	public void testCancelInterrupt() throws InterruptedException {
146	jsr166	1.16	final FutureTask task =
147	jsr166	1.15	new FutureTask(new CheckedInterruptedCallable<Object>() {
148	jsr166	1.16	public Object realCall() throws InterruptedException {
149	jsr166	1.15	Thread.sleep(SMALL_DELAY_MS);
150	jsr166	1.16	return Boolean.TRUE;
151	jsr166	1.15	}});
152
153			Thread t = new Thread(task);
154	dl	1.1	t.start();
155	jsr166	1.15	Thread.sleep(SHORT_DELAY_MS);
156			assertTrue(task.cancel(true));
157			t.join();
158			assertTrue(task.isDone());
159			assertTrue(task.isCancelled());
160	dl	1.1	}
161
162
163	dl	1.5	/**
164	dl	1.6	* cancel(false) does not interrupt a running task
165	dl	1.5	*/
166	jsr166	1.15	public void testCancelNoInterrupt() throws InterruptedException {
167	jsr166	1.16	final FutureTask task =
168	jsr166	1.15	new FutureTask(new CheckedCallable<Object>() {
169	jsr166	1.16	public Object realCall() throws InterruptedException {
170	jsr166	1.15	Thread.sleep(MEDIUM_DELAY_MS);
171	dl	1.1	return Boolean.TRUE;
172	jsr166	1.15	}});
173
174			Thread t = new Thread(task);
175	dl	1.1	t.start();
176	jsr166	1.15	Thread.sleep(SHORT_DELAY_MS);
177			assertTrue(task.cancel(false));
178			t.join();
179			assertTrue(task.isDone());
180			assertTrue(task.isCancelled());
181	dl	1.1	}
182
183	dl	1.5	/**
184	dl	1.6	* set in one thread causes get in another thread to retrieve value
185	dl	1.5	*/
186	jsr166	1.15	public void testGet1() throws InterruptedException {
187	jsr166	1.16	final FutureTask ft =
188	jsr166	1.15	new FutureTask(new CheckedCallable<Object>() {
189	jsr166	1.16	public Object realCall() throws InterruptedException {
190	dl	1.1	return Boolean.TRUE;
191	jsr166	1.15	}});
192	jsr166	1.16	Thread t = new Thread(new CheckedRunnable() {
193	jsr166	1.15	public void realRun() throws Exception {
194			assertSame(Boolean.TRUE, ft.get());
195			}});
196	dl	1.1
197	jsr166	1.15	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	dl	1.1	}
206
207	dl	1.5	/**
208	dl	1.6	* set in one thread causes timed get in another thread to retrieve value
209	dl	1.5	*/
210	jsr166	1.15	public void testTimedGet1() throws InterruptedException {
211	jsr166	1.16	final FutureTask ft =
212	jsr166	1.15	new FutureTask(new CheckedCallable<Object>() {
213	jsr166	1.16	public Object realCall() throws InterruptedException {
214	dl	1.1	return Boolean.TRUE;
215	jsr166	1.15	}});
216	jsr166	1.16	Thread t = new Thread(new CheckedRunnable() {
217	jsr166	1.15	public void realRun() throws Exception {
218			assertSame(Boolean.TRUE, ft.get(SMALL_DELAY_MS, MILLISECONDS));
219			}});
220	jsr166	1.12
221	jsr166	1.15	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	dl	1.1	}
230
231	dl	1.5	/**
232	jsr166	1.20	* Cancelling a task causes timed get in another thread to throw
233			* CancellationException
234	dl	1.5	*/
235	jsr166	1.15	public void testTimedGet_Cancellation() throws InterruptedException {
236	jsr166	1.16	final FutureTask ft =
237	jsr166	1.15	new FutureTask(new CheckedInterruptedCallable<Object>() {
238	jsr166	1.16	public Object realCall() throws InterruptedException {
239	jsr166	1.15	Thread.sleep(SMALL_DELAY_MS);
240	jsr166	1.16	return Boolean.TRUE;
241	jsr166	1.15	}});
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	dl	1.1	}
255	dl	1.6
256	dl	1.5	/**
257	jsr166	1.20	* Cancelling a task causes get in another thread to throw
258			* CancellationException
259	dl	1.5	*/
260	jsr166	1.15	public void testGet_Cancellation() throws InterruptedException {
261	jsr166	1.16	final FutureTask ft =
262	jsr166	1.15	new FutureTask(new CheckedInterruptedCallable<Object>() {
263	jsr166	1.16	public Object realCall() throws InterruptedException {
264	jsr166	1.15	Thread.sleep(SMALL_DELAY_MS);
265	jsr166	1.16	return Boolean.TRUE;
266	jsr166	1.15	}});
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	dl	1.1	}
280	jsr166	1.12
281	dl	1.1
282	dl	1.5	/**
283	dl	1.6	* A runtime exception in task causes get to throw ExecutionException
284	dl	1.5	*/
285	jsr166	1.15	public void testGet_ExecutionException() throws InterruptedException {
286	jsr166	1.16	final FutureTask ft = new FutureTask(new Callable() {
287			public Object call() {
288	jsr166	1.15	return 5/0;
289			}});
290
291			ft.run();
292			try {
293	jsr166	1.16	ft.get();
294	jsr166	1.17	shouldThrow();
295	jsr166	1.16	} catch (ExecutionException success) {
296	jsr166	1.15	assertTrue(success.getCause() instanceof ArithmeticException);
297	dl	1.1	}
298			}
299	jsr166	1.12
300	dl	1.5	/**
301	jsr166	1.20	* A runtime exception in task causes timed get to throw ExecutionException
302	dl	1.5	*/
303	jsr166	1.15	public void testTimedGet_ExecutionException2() throws Exception {
304	jsr166	1.16	final FutureTask ft = new FutureTask(new Callable() {
305			public Object call() {
306	jsr166	1.15	return 5/0;
307			}});
308
309			ft.run();
310	jsr166	1.16	try {
311			ft.get(SHORT_DELAY_MS, MILLISECONDS);
312	jsr166	1.17	shouldThrow();
313	jsr166	1.16	} catch (ExecutionException success) {
314	jsr166	1.15	assertTrue(success.getCause() instanceof ArithmeticException);
315			}
316	dl	1.1	}
317	jsr166	1.12
318	dl	1.1
319	dl	1.5	/**
320	dl	1.6	* Interrupting a waiting get causes it to throw InterruptedException
321	dl	1.5	*/
322	jsr166	1.15	public void testGet_InterruptedException() throws InterruptedException {
323	jsr166	1.16	final FutureTask ft = new FutureTask(new NoOpCallable());
324			Thread t = new Thread(new CheckedInterruptedRunnable() {
325	jsr166	1.15	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	dl	1.1	}
334
335	dl	1.5	/**
336	jsr166	1.20	* Interrupting a waiting timed get causes it to throw InterruptedException
337	dl	1.5	*/
338	jsr166	1.15	public void testTimedGet_InterruptedException2() throws InterruptedException {
339	jsr166	1.16	final FutureTask ft = new FutureTask(new NoOpCallable());
340			Thread t = new Thread(new CheckedInterruptedRunnable() {
341	jsr166	1.15	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	dl	1.1	}
350	jsr166	1.12
351	dl	1.5	/**
352	dl	1.6	* A timed out timed get throws TimeoutException
353	dl	1.5	*/
354	jsr166	1.15	public void testGet_TimeoutException() throws Exception {
355	jsr166	1.16	try {
356	dl	1.4	FutureTask ft = new FutureTask(new NoOpCallable());
357	jsr166	1.16	ft.get(1,MILLISECONDS);
358	jsr166	1.17	shouldThrow();
359	jsr166	1.16	} catch (TimeoutException success) {}
360	dl	1.1	}
361	jsr166	1.12
362	dl	1.1	}