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);
    }

    /**
     * Subclass to expose protected methods
     */
    static class PublicPrivilegedFutureTask extends PrivilegedFutureTask {
        public PublicPrivilegedFutureTask(Callable r) { super(r); }
        public PublicPrivilegedFutureTask(Callable r, ClassLoader ccl, AccessControlContext acc) { super(r, ccl, acc); }
        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(), null, null);
        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(), null, null);
        task.run();
        assertTrue(task.isDone());
        assertTrue(task.reset());       
        assertFalse(task.isDone());
    }

    /**
     * Resetting after cancellation fails
     */
    public void testResetAfterCancel() {
        PublicPrivilegedFutureTask task = new PublicPrivilegedFutureTask(new NoOpCallable(), null, null);
        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(), null, null);
        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(), null, null);
        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(), null, null);
        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(), null, null);
        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(), null, null);
        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(), null, null);
        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(), null, null);
        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;
                } }, null, null);
        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;
                } }, null, null);
        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;
                }
        }, null, null);
        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;
                }
            }, null, null);
        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;
                }
            }, null, null);
        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;
                }
            }, null, null);
        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;
                }
            }, null, null);
        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;
                }
            }, null, null);
        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(), null, null);
        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(), null, null);
        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(), null, null);
            ft.get(1,TimeUnit.MILLISECONDS);
            shouldThrow();
        } catch(TimeoutException success){}
        catch(Exception success){
            unexpectedException();
        }
    }


    /**
     * Without privileges, run with default context throws ACE
     */
    public void testRunWithNoPrivs() {
        try {
            PrivilegedFutureTask task = new PrivilegedFutureTask(new NoOpCallable());
            task.run();
            shouldThrow();
        } catch(AccessControlException success) {
        }
    }


    /**
     * With ContextClassLoader privileges, run with default context succeeds
     */
    public void testRunWithContextClassLoaderPermissions() {
        AdjustablePolicy policy = new AdjustablePolicy();
        policy.addPermission(new RuntimePermission("getContextClassLoader"));
        policy.addPermission(new RuntimePermission("setContextClassLoader"));
        Policy.setPolicy(policy);
        System.setSecurityManager(new SecurityManager());
        
        try {
            PrivilegedFutureTask task = new PrivilegedFutureTask(new NoOpCallable());
            task.run();
            assertTrue(task.isDone());
        } catch(Exception e) {
            unexpectedException();
            
        }
    }

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