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.*;

public class FutureTaskTest extends TestCase {

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

    private static long SHORT_DELAY_MS = 100; 
    private static long MEDIUM_DELAY_MS = 1000;
    private static long LONG_DELAY_MS = 10000; 

    public void testConstructor(){
        try {
            FutureTask task = new FutureTask(null);
            fail("should throw");
        }
        catch(NullPointerException success) {
        }
    }

    public void testConstructor2(){
        try {
            FutureTask task = new FutureTask(null, Boolean.TRUE);
            fail("should throw");
        }
        catch(NullPointerException success) {
        }
    }

    public void testIsDone(){
        FutureTask task = new FutureTask( new Callable() {
                public Object call() { return Boolean.TRUE; } });
        task.run();
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

    public void testCancelBeforeRun() {
        FutureTask task = new FutureTask( new Callable() {
                public Object call() { return Boolean.TRUE; } });
        assertTrue(task.cancel(false));
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    public void testCancelBeforeRun2() {
        FutureTask task = new FutureTask( new Callable() {
                public Object call() { return Boolean.TRUE; } });
        assertTrue(task.cancel(true));
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    public void testCancelAfterRun() {
        FutureTask task = new FutureTask( new Callable() {
                public Object call() { return Boolean.TRUE; } });
        task.run();
        assertFalse(task.cancel(false));
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

    public void testCancelInterrupt(){
        FutureTask task = new FutureTask( new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(SHORT_DELAY_MS* 2);
                        fail("should throw");
                    }
                    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){
            fail("unexpected exception");
        }
    }


    public void testCancelNoInterrupt(){
        FutureTask task = new FutureTask( new Callable() {
                public Object call() {
                    try {
                        Thread.sleep(SHORT_DELAY_MS* 2);
                    }
                    catch (InterruptedException success) {
                        fail("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){
            fail("unexpected exception");
        }
    }

    public void testGet1() {
        final FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    try{
                        Thread.sleep(MEDIUM_DELAY_MS);
                    } catch(InterruptedException e){
                        fail("unexpected exception");
                    }
                    return Boolean.TRUE;
                }
        });
        Thread t = new Thread(new Runnable(){
                public void run(){
                    try{
                        ft.get();
                    } catch(Exception e){
                        fail("unexpected exception");
                    }
                }
            });
        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){
            fail("unexpected exception");

        }       
    }

    public void testTimedGet1() {
        final FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    try{
                        Thread.sleep(MEDIUM_DELAY_MS);
                    } catch(InterruptedException e){
                        fail("unexpected exception");
                    }
                    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){
                        fail("unexpected exception");
                    }
                }
            });
        try{
            assertFalse(ft.isDone());
            assertFalse(ft.isCancelled());
            t.start();
            ft.run();
            t.join();
            assertTrue(ft.isDone());
            assertFalse(ft.isCancelled());
        } catch(InterruptedException e){
            fail("unexpected exception");
            
        }       
    }


    public void testGet_Cancellation(){
        final FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    try{
                        Thread.sleep(MEDIUM_DELAY_MS);
                    } catch(InterruptedException e){
                        fail("unexpected exception");
                    }
                    return Boolean.TRUE;
                }
            });
        try {
            Thread.sleep(SHORT_DELAY_MS);
            Thread t = new Thread(new Runnable(){
                    public void run(){
                        try{
                            ft.get();
                            fail("should throw");
                        } catch(CancellationException success){
                        }
                        catch(Exception e){
                            fail("unexpected exception");
                        }
                    }
                });
            t.start(); 
            ft.cancel(true);
            t.join();
        } catch(InterruptedException success){
            fail("unexpected exception");
        }
    }
    
    public void testGet_Cancellation2(){
        final FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    try{
                        Thread.sleep(SHORT_DELAY_MS);
                    } catch(InterruptedException e) {
                        fail("unexpected exception");
                    }
                    return Boolean.TRUE;
                }
            });
        try{
            Thread.sleep(100);
            Thread t = new Thread(new Runnable(){
                    public void run(){
                        try{
                            ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
                            fail("should throw");
                        } catch(CancellationException success) {}
                        catch(Exception e){
                            fail("unexpected exception");
                        }
                    }
                });
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            ft.cancel(true);
            Thread.sleep(SHORT_DELAY_MS);
            t.join();
        } catch(InterruptedException ie){
            fail("unexpected exception");
        }
    }

    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();
            fail("should throw");
        } catch(ExecutionException success){
        }
        catch(Exception e){
            fail("unexpected exception");
        }
    }
  
    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);
            fail("should throw");
        } catch(ExecutionException success) { 
        } catch(TimeoutException success) { } // unlikely but OK
        catch(Exception e){
            fail("unexpected exception");
        }
    }
      

    public void testGet_InterruptedException(){
        final FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    return new Object();
                }
            });
        Thread t = new Thread(new Runnable(){
                public void run(){                  
                    try{
                        ft.get();
                        fail("should throw");
                    } catch(InterruptedException success){
                    } catch(Exception e){
                        fail("unexpected exception");
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e){
            fail("unexpected exception");
        }
    }

    public void testTimedGet_InterruptedException2(){
        final FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    return new Object();
                }
            });
        Thread t = new Thread(new Runnable(){
                public void run(){                  
                    try{
                        ft.get(100,TimeUnit.SECONDS);
                        fail("should throw");
                    } catch(InterruptedException success){}
                    catch(Exception e){
                        fail("unexpected exception");
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch(Exception e){
            fail("unexpected exception");
        }
    }
    
    public void testGet_TimeoutException(){
        FutureTask ft = new FutureTask(new Callable(){
                public Object call(){
                    return new Object();
                }
            }); 
        try{
            ft.get(1,TimeUnit.MILLISECONDS);
            fail("should throw");
        } catch(TimeoutException success){}
        catch(Exception success){
            fail("unexpected exception");
        }
        
        
    }
    
}
Revision:	1.3
Committed:	Fri Sep 12 15:40:25 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+18 -0 lines
Log Message:	test for null runnables
#	User	Rev	Content
1	dl	1.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
11			public class FutureTaskTest extends TestCase {
12
13			public static void main(String[] args) {
14			junit.textui.TestRunner.run (suite());
15			}
16			public static Test suite() {
17			return new TestSuite(FutureTaskTest.class);
18			}
19
20			private static long SHORT_DELAY_MS = 100;
21			private static long MEDIUM_DELAY_MS = 1000;
22			private static long LONG_DELAY_MS = 10000;
23
24	dl	1.3	public void testConstructor(){
25			try {
26			FutureTask task = new FutureTask(null);
27			fail("should throw");
28			}
29			catch(NullPointerException success) {
30			}
31			}
32
33			public void testConstructor2(){
34			try {
35			FutureTask task = new FutureTask(null, Boolean.TRUE);
36			fail("should throw");
37			}
38			catch(NullPointerException success) {
39			}
40			}
41
42	dl	1.1	public void testIsDone(){
43			FutureTask task = new FutureTask( new Callable() {
44			public Object call() { return Boolean.TRUE; } });
45			task.run();
46			assertTrue(task.isDone());
47			assertFalse(task.isCancelled());
48			}
49
50			public void testCancelBeforeRun() {
51			FutureTask task = new FutureTask( new Callable() {
52			public Object call() { return Boolean.TRUE; } });
53			assertTrue(task.cancel(false));
54			task.run();
55			assertTrue(task.isDone());
56			assertTrue(task.isCancelled());
57			}
58
59			public void testCancelBeforeRun2() {
60			FutureTask task = new FutureTask( new Callable() {
61			public Object call() { return Boolean.TRUE; } });
62			assertTrue(task.cancel(true));
63			task.run();
64			assertTrue(task.isDone());
65			assertTrue(task.isCancelled());
66			}
67
68			public void testCancelAfterRun() {
69			FutureTask task = new FutureTask( new Callable() {
70			public Object call() { return Boolean.TRUE; } });
71			task.run();
72			assertFalse(task.cancel(false));
73			assertTrue(task.isDone());
74			assertFalse(task.isCancelled());
75			}
76
77			public void testCancelInterrupt(){
78			FutureTask task = new FutureTask( new Callable() {
79			public Object call() {
80			try {
81			Thread.sleep(SHORT_DELAY_MS* 2);
82			fail("should throw");
83			}
84			catch (InterruptedException success) {}
85			return Boolean.TRUE;
86			} });
87			Thread t = new Thread(task);
88			t.start();
89
90			try{
91			Thread.sleep(SHORT_DELAY_MS);
92			assertTrue(task.cancel(true));
93			t.join();
94			assertTrue(task.isDone());
95			assertTrue(task.isCancelled());
96			} catch(InterruptedException e){
97			fail("unexpected exception");
98			}
99			}
100
101
102			public void testCancelNoInterrupt(){
103			FutureTask task = new FutureTask( new Callable() {
104			public Object call() {
105			try {
106			Thread.sleep(SHORT_DELAY_MS* 2);
107			}
108			catch (InterruptedException success) {
109			fail("should not interrupt");
110			}
111			return Boolean.TRUE;
112			} });
113			Thread t = new Thread(task);
114			t.start();
115
116			try{
117			Thread.sleep(SHORT_DELAY_MS);
118			assertTrue(task.cancel(false));
119			t.join();
120			assertTrue(task.isDone());
121			assertTrue(task.isCancelled());
122			} catch(InterruptedException e){
123			fail("unexpected exception");
124			}
125			}
126
127			public void testGet1() {
128			final FutureTask ft = new FutureTask(new Callable(){
129			public Object call(){
130			try{
131			Thread.sleep(MEDIUM_DELAY_MS);
132	dl	1.2	} catch(InterruptedException e){
133	dl	1.1	fail("unexpected exception");
134			}
135			return Boolean.TRUE;
136			}
137			});
138			Thread t = new Thread(new Runnable(){
139			public void run(){
140			try{
141			ft.get();
142	dl	1.2	} catch(Exception e){
143	dl	1.1	fail("unexpected exception");
144			}
145			}
146			});
147			try{
148			assertFalse(ft.isDone());
149			assertFalse(ft.isCancelled());
150			t.start();
151			Thread.sleep(SHORT_DELAY_MS);
152			ft.run();
153			t.join();
154			assertTrue(ft.isDone());
155			assertFalse(ft.isCancelled());
156			} catch(InterruptedException e){
157			fail("unexpected exception");
158
159			}
160			}
161
162			public void testTimedGet1() {
163			final FutureTask ft = new FutureTask(new Callable(){
164			public Object call(){
165			try{
166			Thread.sleep(MEDIUM_DELAY_MS);
167	dl	1.2	} catch(InterruptedException e){
168	dl	1.1	fail("unexpected exception");
169			}
170			return Boolean.TRUE;
171			}
172			});
173			Thread t = new Thread(new Runnable(){
174			public void run(){
175			try{
176			ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
177			} catch(TimeoutException success) {
178			} catch(Exception e){
179			fail("unexpected exception");
180			}
181			}
182			});
183			try{
184			assertFalse(ft.isDone());
185			assertFalse(ft.isCancelled());
186			t.start();
187			ft.run();
188			t.join();
189			assertTrue(ft.isDone());
190			assertFalse(ft.isCancelled());
191			} catch(InterruptedException e){
192			fail("unexpected exception");
193
194			}
195			}
196
197
198			public void testGet_Cancellation(){
199			final FutureTask ft = new FutureTask(new Callable(){
200			public Object call(){
201			try{
202			Thread.sleep(MEDIUM_DELAY_MS);
203	dl	1.2	} catch(InterruptedException e){
204	dl	1.1	fail("unexpected exception");
205			}
206			return Boolean.TRUE;
207			}
208			});
209			try {
210			Thread.sleep(SHORT_DELAY_MS);
211			Thread t = new Thread(new Runnable(){
212			public void run(){
213			try{
214			ft.get();
215			fail("should throw");
216	dl	1.2	} catch(CancellationException success){
217	dl	1.1	}
218			catch(Exception e){
219			fail("unexpected exception");
220			}
221			}
222			});
223			t.start();
224			ft.cancel(true);
225			t.join();
226	dl	1.2	} catch(InterruptedException success){
227	dl	1.1	fail("unexpected exception");
228			}
229			}
230
231			public void testGet_Cancellation2(){
232			final FutureTask ft = new FutureTask(new Callable(){
233			public Object call(){
234			try{
235			Thread.sleep(SHORT_DELAY_MS);
236			} catch(InterruptedException e) {
237			fail("unexpected exception");
238			}
239			return Boolean.TRUE;
240			}
241			});
242			try{
243			Thread.sleep(100);
244			Thread t = new Thread(new Runnable(){
245			public void run(){
246			try{
247			ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
248			fail("should throw");
249	dl	1.2	} catch(CancellationException success) {}
250	dl	1.1	catch(Exception e){
251			fail("unexpected exception");
252			}
253			}
254			});
255			t.start();
256			Thread.sleep(SHORT_DELAY_MS);
257			ft.cancel(true);
258			Thread.sleep(SHORT_DELAY_MS);
259			t.join();
260	dl	1.2	} catch(InterruptedException ie){
261	dl	1.1	fail("unexpected exception");
262			}
263			}
264
265			public void testGet_ExecutionException(){
266			final FutureTask ft = new FutureTask(new Callable(){
267			public Object call(){
268			int i = 5/0;
269			return Boolean.TRUE;
270			}
271			});
272			try{
273			ft.run();
274			ft.get();
275			fail("should throw");
276	dl	1.2	} catch(ExecutionException success){
277	dl	1.1	}
278			catch(Exception e){
279			fail("unexpected exception");
280			}
281			}
282
283			public void testTimedGet_ExecutionException2(){
284			final FutureTask ft = new FutureTask(new Callable(){
285			public Object call(){
286			int i = 5/0;
287			return Boolean.TRUE;
288			}
289			});
290			try{
291			ft.run();
292			ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
293			fail("should throw");
294	dl	1.2	} catch(ExecutionException success) {
295			} catch(TimeoutException success) { } // unlikely but OK
296	dl	1.1	catch(Exception e){
297			fail("unexpected exception");
298			}
299			}
300
301
302			public void testGet_InterruptedException(){
303			final FutureTask ft = new FutureTask(new Callable(){
304			public Object call(){
305			return new Object();
306			}
307			});
308			Thread t = new Thread(new Runnable(){
309			public void run(){
310			try{
311			ft.get();
312			fail("should throw");
313			} catch(InterruptedException success){
314			} catch(Exception e){
315			fail("unexpected exception");
316			}
317			}
318			});
319			try {
320			t.start();
321			Thread.sleep(SHORT_DELAY_MS);
322			t.interrupt();
323			t.join();
324			} catch(Exception e){
325			fail("unexpected exception");
326			}
327			}
328
329			public void testTimedGet_InterruptedException2(){
330			final FutureTask ft = new FutureTask(new Callable(){
331			public Object call(){
332			return new Object();
333			}
334			});
335			Thread t = new Thread(new Runnable(){
336			public void run(){
337			try{
338			ft.get(100,TimeUnit.SECONDS);
339			fail("should throw");
340	dl	1.2	} catch(InterruptedException success){}
341	dl	1.1	catch(Exception e){
342			fail("unexpected exception");
343			}
344			}
345			});
346			try {
347			t.start();
348			Thread.sleep(SHORT_DELAY_MS);
349			t.interrupt();
350			t.join();
351			} catch(Exception e){
352			fail("unexpected exception");
353			}
354			}
355
356			public void testGet_TimeoutException(){
357			FutureTask ft = new FutureTask(new Callable(){
358			public Object call(){
359			return new Object();
360			}
361			});
362			try{
363			ft.get(1,TimeUnit.MILLISECONDS);
364			fail("should throw");
365	dl	1.2	} catch(TimeoutException success){}
366			catch(Exception success){
367	dl	1.1	fail("unexpected exception");
368			}
369
370
371			}
372
373			}