test/tck/FutureTaskTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, 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 MyFutureTask extends FutureTask {
        public MyFutureTask(Callable r) { super(r); }
        public boolean reset() { return super.reset(); }
        public void setCancelled() { super.setCancelled(); }
        public void setDone() { super.setDone(); }
        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());
    }

    /**
     * reset of a done task succeeds and changes status to not done
     */
    public void testReset() {
        MyFutureTask task = new MyFutureTask(new NoOpCallable());
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.reset());       
        assertFalse(task.isDone());
    }

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

    /**
     * setDone of new task causes isDone to be true
     */
    public void testSetDone() {
        MyFutureTask task = new MyFutureTask(new NoOpCallable());
        task.setDone();
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

    /**
     * setCancelled of a new task causes isCancelled to be true
     */
    public void testSetCancelled() {
        MyFutureTask task = new MyFutureTask(new NoOpCallable());
        assertTrue(task.cancel(false));
        task.setCancelled();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

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