test/tck/PrivilegedFutureTaskTest.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.*;
import java.security.*;

public class PrivilegedFutureTaskTest extends JSR166TestCase {

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

    Policy savedPolicy;

    /**
     * Establish permissions for get/set for contextClassLoader for each test
     */
    public void setUp() {
        super.setUp();
        savedPolicy = Policy.getPolicy();
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        //      System.setSecurityManager(new SecurityManager());
    }

    public void tearDown() {
        Policy.setPolicy(savedPolicy);
        super.tearDown();
    }

    /**
     * Subclass to expose protected methods
     */
    static class PublicPrivilegedFutureTask extends PrivilegedFutureTask {
        public PublicPrivilegedFutureTask(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 {
            PrivilegedFutureTask task = new PrivilegedFutureTask(null);
            shouldThrow();
        }
        catch(NullPointerException success) {
        }
    }

    /**
     * isDone is true when a task completes
     */
    public void testIsDone() {
        PrivilegedFutureTask task = new PrivilegedFutureTask( 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() {
        PublicPrivilegedFutureTask task = new PublicPrivilegedFutureTask(new NoOpCallable());
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.reset());       
        assertFalse(task.isDone());
    }

    /**
     * Resetting after cancellation fails
     */
    public void testResetAfterCancel() {
        PublicPrivilegedFutureTask task = new PublicPrivilegedFutureTask(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() {
        PublicPrivilegedFutureTask task = new PublicPrivilegedFutureTask(new NoOpCallable());
        task.setDone();
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

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

    /**
     * setting value gauses get to return it
     */
    public void testSet() {
        PublicPrivilegedFutureTask task = new PublicPrivilegedFutureTask(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();
        PublicPrivilegedFutureTask task = new PublicPrivilegedFutureTask(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() {
        PrivilegedFutureTask task = new PrivilegedFutureTask( new NoOpCallable());
        assertTrue(task.cancel(false));
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    /**
     * Cancel(true) before run succeeds
     */
    public void testCancelBeforeRun2() {
        PrivilegedFutureTask task = new PrivilegedFutureTask( new NoOpCallable());
        assertTrue(task.cancel(true));
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.isCancelled());
    }

    /**
     * cancel of a completed task fails
     */
    public void testCancelAfterRun() {
        PrivilegedFutureTask task = new PrivilegedFutureTask( new NoOpCallable());
        task.run();
        assertFalse(task.cancel(false));
        assertTrue(task.isDone());
        assertFalse(task.isCancelled());
    }

    /**
     * cancel(true) interrupts a running task
     */
    public void testCancelInterrupt() {
        PrivilegedFutureTask task = new PrivilegedFutureTask( 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() {
        PrivilegedFutureTask task = new PrivilegedFutureTask( 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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 PrivilegedFutureTask ft = new PrivilegedFutureTask(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 {
            PrivilegedFutureTask ft = new PrivilegedFutureTask(new NoOpCallable());
            ft.get(1,TimeUnit.MILLISECONDS);
            shouldThrow();
        } catch(TimeoutException success){}
        catch(Exception success){
            unexpectedException();
        }
    }

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