test/tck/FutureTaskTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
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);
    }

    void checkNotDone(Future<?> f) {
        assertFalse(f.isDone());
        assertFalse(f.isCancelled());
    }

    <T> void checkCompletedNormally(Future<T> f, T expected) {
        assertTrue(f.isDone());
        assertFalse(f.isCancelled());

        try {
            assertSame(expected, f.get());
        } catch (Throwable fail) { threadUnexpectedException(fail); }
        try {
            assertSame(expected, f.get(5L, SECONDS));
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertFalse(f.cancel(false));
        assertFalse(f.cancel(true));
    }

    void checkCancelled(Future<?> f) {
        assertTrue(f.isDone());
        assertTrue(f.isCancelled());

        try {
            f.get();
            shouldThrow();
        } catch (CancellationException success) {
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {
            f.get(5L, SECONDS);
            shouldThrow();
        } catch (CancellationException success) {
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertFalse(f.cancel(false));
        assertFalse(f.cancel(true));
    }

    void checkCompletedAbnormally(Future<?> f, Throwable t) {
        assertTrue(f.isDone());
        assertFalse(f.isCancelled());

        try {
            f.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertSame(t, success.getCause());
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {
            f.get(5L, SECONDS);
            shouldThrow();
        } catch (ExecutionException success) {
            assertSame(t, success.getCause());
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        assertFalse(f.cancel(false));
        assertFalse(f.cancel(true));
    }

    /**
     * Subclass to expose protected methods
     */
    static class PublicFutureTask extends FutureTask {
        public PublicFutureTask(Callable r) { super(r); }
        public boolean runAndReset() { return super.runAndReset(); }
        public void set(Object x) { super.set(x); }
        public void setException(Throwable t) { super.setException(t); }
    }

    /**
     * Creating a future with a null callable throws NPE
     */
    public void testConstructor() {
        try {
            FutureTask task = new FutureTask(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * creating a future with null runnable fails
     */
    public void testConstructor2() {
        try {
            FutureTask task = new FutureTask(null, Boolean.TRUE);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * isDone is true when a task completes
     */
    public void testIsDone() {
        FutureTask task = new FutureTask(new NoOpCallable());
        task.run();
        assertTrue(task.isDone());
        checkCompletedNormally(task, Boolean.TRUE);
    }

    /**
     * runAndReset of a non-cancelled task succeeds
     */
    public void testRunAndReset() {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        assertTrue(task.runAndReset());
        checkNotDone(task);
    }

    /**
     * runAndReset after cancellation fails
     */
    public void testResetAfterCancel() {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        assertTrue(task.cancel(false));
        assertFalse(task.runAndReset());
        checkCancelled(task);
    }


    /**
     * setting value causes get to return it
     */
    public void testSet() throws Exception {
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        task.set(one);
        assertSame(task.get(), one);
        checkCompletedNormally(task, one);
    }

    /**
     * setException causes get to throw ExecutionException
     */
    public void testSetException() throws Exception {
        Exception nse = new NoSuchElementException();
        PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
        task.setException(nse);
        try {
            Object x = task.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertSame(success.getCause(), nse);
            checkCompletedAbnormally(task, nse);
        }
    }

    /**
     * Cancelling before running succeeds
     */
    public void testCancelBeforeRun() {
        FutureTask task = new FutureTask(new NoOpCallable());
        assertTrue(task.cancel(false));
        task.run();
        checkCancelled(task);
    }

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

    /**
     * cancel of a completed task fails
     */
    public void testCancelAfterRun() {
        FutureTask task = new FutureTask(new NoOpCallable());
        task.run();
        assertFalse(task.cancel(false));
        checkCompletedNormally(task, Boolean.TRUE);
    }

    /**
     * cancel(true) interrupts a running task
     */
    public void testCancelInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final FutureTask task =
            new FutureTask(new CheckedCallable<Object>() {
                public Object realCall() {
                    threadStarted.countDown();
                    long t0 = System.nanoTime();
                    for (;;) {
                        if (Thread.interrupted())
                            return Boolean.TRUE;
                        if (millisElapsedSince(t0) > MEDIUM_DELAY_MS)
                            fail("interrupt not delivered");
                        Thread.yield();
                    }
                }});

        Thread t = newStartedThread(task);
        threadStarted.await();
        assertTrue(task.cancel(true));
        checkCancelled(task);
        awaitTermination(t, MEDIUM_DELAY_MS);
        checkCancelled(task);
    }

    /**
     * cancel(false) does not interrupt a running task
     */
    public void testCancelNoInterrupt() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final CountDownLatch cancelled = new CountDownLatch(1);
        final FutureTask<Boolean> task =
            new FutureTask<Boolean>(new CheckedCallable<Boolean>() {
                public Boolean realCall() throws InterruptedException {
                    threadStarted.countDown();
                    cancelled.await(MEDIUM_DELAY_MS, MILLISECONDS);
                    assertFalse(Thread.interrupted());
                    return Boolean.TRUE;
                }});

        Thread t = newStartedThread(task);
        threadStarted.await();
        assertTrue(task.cancel(false));
        checkCancelled(task);
        cancelled.countDown();
        awaitTermination(t, MEDIUM_DELAY_MS);
        checkCancelled(task);
    }

    /**
     * set in one thread causes get in another thread to retrieve value
     */
    public void testGet1() throws InterruptedException {
        final FutureTask task =
            new FutureTask(new CheckedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    return Boolean.TRUE;
                }});
        checkNotDone(task);

        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(Boolean.TRUE, task.get());
            }});

        task.run();
        checkCompletedNormally(task, Boolean.TRUE);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * set in one thread causes timed get in another thread to retrieve value
     */
    public void testTimedGet1() throws InterruptedException {
        final FutureTask task =
            new FutureTask(new CheckedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    return Boolean.TRUE;
                }});
        checkNotDone(task);

        Thread t = newStartedThread(new CheckedRunnable() {
            public void realRun() throws Exception {
                assertSame(Boolean.TRUE, task.get(SMALL_DELAY_MS, MILLISECONDS));
            }});

        task.run();
        checkCompletedNormally(task, Boolean.TRUE);
        awaitTermination(t, MEDIUM_DELAY_MS);
    }

    /**
     * Cancelling a task causes timed get in another thread to throw
     * CancellationException
     */
    public void testTimedGet_Cancellation() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(2);
        final FutureTask task =
            new FutureTask(new CheckedInterruptedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    threadStarted.countDown();
                    Thread.sleep(LONG_DELAY_MS);
                    return Boolean.TRUE;
                }});

        Thread t1 = new ThreadShouldThrow(CancellationException.class) {
            public void realRun() throws Exception {
                threadStarted.countDown();
                task.get(MEDIUM_DELAY_MS, MILLISECONDS);
            }};
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        threadStarted.await();
        task.cancel(true);
        awaitTermination(t1, MEDIUM_DELAY_MS);
        awaitTermination(t2, MEDIUM_DELAY_MS);
        checkCancelled(task);
    }

    /**
     * Cancelling a task causes get in another thread to throw
     * CancellationException
     */
    public void testGet_Cancellation() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(2);
        final FutureTask task =
            new FutureTask(new CheckedInterruptedCallable<Object>() {
                public Object realCall() throws InterruptedException {
                    threadStarted.countDown();
                    Thread.sleep(LONG_DELAY_MS);
                    return Boolean.TRUE;
                }});

        Thread t1 = new ThreadShouldThrow(CancellationException.class) {
            public void realRun() throws Exception {
                threadStarted.countDown();
                task.get();
            }};
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        threadStarted.await();
        task.cancel(true);
        awaitTermination(t1, MEDIUM_DELAY_MS);
        awaitTermination(t2, MEDIUM_DELAY_MS);
        checkCancelled(task);
    }


    /**
     * A runtime exception in task causes get to throw ExecutionException
     */
    public void testGet_ExecutionException() throws InterruptedException {
        final FutureTask task = new FutureTask(new Callable() {
            public Object call() {
                return 5/0;
            }});

        task.run();
        try {
            task.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof ArithmeticException);
            checkCompletedAbnormally(task, success.getCause());
        }
    }

    /**
     * A runtime exception in task causes timed get to throw ExecutionException
     */
    public void testTimedGet_ExecutionException2() throws Exception {
        final FutureTask task = new FutureTask(new Callable() {
            public Object call() {
                return 5/0;
            }});

        task.run();
        try {
            task.get(SHORT_DELAY_MS, MILLISECONDS);
            shouldThrow();
        } catch (ExecutionException success) {
            assertTrue(success.getCause() instanceof ArithmeticException);
            checkCompletedAbnormally(task, success.getCause());
        }
    }


    /**
     * Interrupting a waiting get causes it to throw InterruptedException
     */
    public void testGet_InterruptedException() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final FutureTask task = new FutureTask(new NoOpCallable());
        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                task.get();
            }});

        threadStarted.await();
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
        checkNotDone(task);
    }

    /**
     * Interrupting a waiting timed get causes it to throw InterruptedException
     */
    public void testTimedGet_InterruptedException2() throws InterruptedException {
        final CountDownLatch threadStarted = new CountDownLatch(1);
        final FutureTask task = new FutureTask(new NoOpCallable());
        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
            public void realRun() throws Exception {
                threadStarted.countDown();
                task.get(LONG_DELAY_MS, MILLISECONDS);
            }});

        threadStarted.await();
        t.interrupt();
        awaitTermination(t, MEDIUM_DELAY_MS);
        checkNotDone(task);
    }

    /**
     * A timed out timed get throws TimeoutException
     */
    public void testGet_TimeoutException() throws Exception {
        try {
            FutureTask task = new FutureTask(new NoOpCallable());
            task.get(1, MILLISECONDS);
            shouldThrow();
        } catch (TimeoutException success) {}
    }

}
Revision:	1.22
Committed:	Sun Nov 28 20:20:00 2010 UTC (13 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.21:	+169 -91 lines
Log Message:	optimize; add more assertions
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.10	* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/licenses/publicdomain
5	jsr166	1.12	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9			import junit.framework.*;
10			import java.util.concurrent.*;
11	jsr166	1.15	import static java.util.concurrent.TimeUnit.MILLISECONDS;
12	jsr166	1.22	import static java.util.concurrent.TimeUnit.SECONDS;
13	dl	1.4	import java.util.*;
14	dl	1.1
15	dl	1.4	public class FutureTaskTest extends JSR166TestCase {
16	dl	1.1
17			public static void main(String[] args) {
18	jsr166	1.19	junit.textui.TestRunner.run(suite());
19	dl	1.1	}
20			public static Test suite() {
21	jsr166	1.16	return new TestSuite(FutureTaskTest.class);
22	dl	1.1	}
23
24	jsr166	1.22	void checkNotDone(Future<?> f) {
25			assertFalse(f.isDone());
26			assertFalse(f.isCancelled());
27			}
28
29			<T> void checkCompletedNormally(Future<T> f, T expected) {
30			assertTrue(f.isDone());
31			assertFalse(f.isCancelled());
32
33			try {
34			assertSame(expected, f.get());
35			} catch (Throwable fail) { threadUnexpectedException(fail); }
36			try {
37			assertSame(expected, f.get(5L, SECONDS));
38			} catch (Throwable fail) { threadUnexpectedException(fail); }
39
40			assertFalse(f.cancel(false));
41			assertFalse(f.cancel(true));
42			}
43
44			void checkCancelled(Future<?> f) {
45			assertTrue(f.isDone());
46			assertTrue(f.isCancelled());
47
48			try {
49			f.get();
50			shouldThrow();
51			} catch (CancellationException success) {
52			} catch (Throwable fail) { threadUnexpectedException(fail); }
53
54			try {
55			f.get(5L, SECONDS);
56			shouldThrow();
57			} catch (CancellationException success) {
58			} catch (Throwable fail) { threadUnexpectedException(fail); }
59
60			assertFalse(f.cancel(false));
61			assertFalse(f.cancel(true));
62			}
63
64			void checkCompletedAbnormally(Future<?> f, Throwable t) {
65			assertTrue(f.isDone());
66			assertFalse(f.isCancelled());
67
68			try {
69			f.get();
70			shouldThrow();
71			} catch (ExecutionException success) {
72			assertSame(t, success.getCause());
73			} catch (Throwable fail) { threadUnexpectedException(fail); }
74
75			try {
76			f.get(5L, SECONDS);
77			shouldThrow();
78			} catch (ExecutionException success) {
79			assertSame(t, success.getCause());
80			} catch (Throwable fail) { threadUnexpectedException(fail); }
81
82			assertFalse(f.cancel(false));
83			assertFalse(f.cancel(true));
84			}
85
86	dl	1.4	/**
87			* Subclass to expose protected methods
88			*/
89	dl	1.7	static class PublicFutureTask extends FutureTask {
90			public PublicFutureTask(Callable r) { super(r); }
91	dl	1.9	public boolean runAndReset() { return super.runAndReset(); }
92	dl	1.4	public void set(Object x) { super.set(x); }
93			public void setException(Throwable t) { super.setException(t); }
94			}
95	dl	1.1
96	dl	1.5	/**
97	dl	1.6	* Creating a future with a null callable throws NPE
98	dl	1.5	*/
99			public void testConstructor() {
100	dl	1.3	try {
101			FutureTask task = new FutureTask(null);
102	jsr166	1.17	shouldThrow();
103	jsr166	1.15	} catch (NullPointerException success) {}
104	dl	1.3	}
105
106	dl	1.5	/**
107	dl	1.6	* creating a future with null runnable fails
108	dl	1.5	*/
109			public void testConstructor2() {
110	dl	1.3	try {
111			FutureTask task = new FutureTask(null, Boolean.TRUE);
112	jsr166	1.17	shouldThrow();
113	jsr166	1.15	} catch (NullPointerException success) {}
114	dl	1.3	}
115
116	dl	1.5	/**
117	dl	1.6	* isDone is true when a task completes
118	dl	1.5	*/
119			public void testIsDone() {
120	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
121	jsr166	1.16	task.run();
122			assertTrue(task.isDone());
123	jsr166	1.22	checkCompletedNormally(task, Boolean.TRUE);
124	dl	1.4	}
125
126	dl	1.5	/**
127	dl	1.9	* runAndReset of a non-cancelled task succeeds
128	dl	1.5	*/
129	dl	1.9	public void testRunAndReset() {
130	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
131	jsr166	1.16	assertTrue(task.runAndReset());
132	jsr166	1.22	checkNotDone(task);
133	dl	1.4	}
134
135	dl	1.5	/**
136	dl	1.9	* runAndReset after cancellation fails
137	dl	1.5	*/
138	dl	1.4	public void testResetAfterCancel() {
139	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
140	dl	1.4	assertTrue(task.cancel(false));
141	jsr166	1.16	assertFalse(task.runAndReset());
142	jsr166	1.22	checkCancelled(task);
143	dl	1.4	}
144
145	dl	1.1
146	dl	1.5	/**
147	dl	1.11	* setting value causes get to return it
148	dl	1.5	*/
149	jsr166	1.15	public void testSet() throws Exception {
150	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
151	dl	1.4	task.set(one);
152	jsr166	1.18	assertSame(task.get(), one);
153	jsr166	1.22	checkCompletedNormally(task, one);
154	dl	1.4	}
155
156	dl	1.5	/**
157	dl	1.6	* setException causes get to throw ExecutionException
158	dl	1.5	*/
159	jsr166	1.15	public void testSetException() throws Exception {
160	dl	1.4	Exception nse = new NoSuchElementException();
161	dl	1.7	PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
162	dl	1.4	task.setException(nse);
163			try {
164			Object x = task.get();
165	jsr166	1.17	shouldThrow();
166	jsr166	1.15	} catch (ExecutionException success) {
167			assertSame(success.getCause(), nse);
168	jsr166	1.22	checkCompletedAbnormally(task, nse);
169	dl	1.4	}
170			}
171
172	dl	1.5	/**
173	jsr166	1.21	* Cancelling before running succeeds
174	dl	1.5	*/
175	dl	1.1	public void testCancelBeforeRun() {
176	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
177	dl	1.1	assertTrue(task.cancel(false));
178	jsr166	1.16	task.run();
179	jsr166	1.22	checkCancelled(task);
180	dl	1.1	}
181
182	dl	1.5	/**
183	dl	1.6	* Cancel(true) before run succeeds
184	dl	1.5	*/
185	dl	1.1	public void testCancelBeforeRun2() {
186	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
187	dl	1.1	assertTrue(task.cancel(true));
188	jsr166	1.16	task.run();
189	jsr166	1.22	checkCancelled(task);
190	dl	1.1	}
191
192	dl	1.5	/**
193	dl	1.6	* cancel of a completed task fails
194	dl	1.5	*/
195	dl	1.1	public void testCancelAfterRun() {
196	jsr166	1.15	FutureTask task = new FutureTask(new NoOpCallable());
197	jsr166	1.16	task.run();
198	dl	1.1	assertFalse(task.cancel(false));
199	jsr166	1.22	checkCompletedNormally(task, Boolean.TRUE);
200	dl	1.1	}
201
202	dl	1.5	/**
203	dl	1.6	* cancel(true) interrupts a running task
204	dl	1.5	*/
205	jsr166	1.15	public void testCancelInterrupt() throws InterruptedException {
206	jsr166	1.22	final CountDownLatch threadStarted = new CountDownLatch(1);
207	jsr166	1.16	final FutureTask task =
208	jsr166	1.22	new FutureTask(new CheckedCallable<Object>() {
209			public Object realCall() {
210			threadStarted.countDown();
211			long t0 = System.nanoTime();
212			for (;;) {
213			if (Thread.interrupted())
214			return Boolean.TRUE;
215			if (millisElapsedSince(t0) > MEDIUM_DELAY_MS)
216			fail("interrupt not delivered");
217			Thread.yield();
218			}
219	jsr166	1.15	}});
220
221	jsr166	1.22	Thread t = newStartedThread(task);
222			threadStarted.await();
223	jsr166	1.15	assertTrue(task.cancel(true));
224	jsr166	1.22	checkCancelled(task);
225			awaitTermination(t, MEDIUM_DELAY_MS);
226			checkCancelled(task);
227	dl	1.1	}
228
229	dl	1.5	/**
230	dl	1.6	* cancel(false) does not interrupt a running task
231	dl	1.5	*/
232	jsr166	1.15	public void testCancelNoInterrupt() throws InterruptedException {
233	jsr166	1.22	final CountDownLatch threadStarted = new CountDownLatch(1);
234			final CountDownLatch cancelled = new CountDownLatch(1);
235			final FutureTask<Boolean> task =
236			new FutureTask<Boolean>(new CheckedCallable<Boolean>() {
237			public Boolean realCall() throws InterruptedException {
238			threadStarted.countDown();
239			cancelled.await(MEDIUM_DELAY_MS, MILLISECONDS);
240			assertFalse(Thread.interrupted());
241	dl	1.1	return Boolean.TRUE;
242	jsr166	1.15	}});
243
244	jsr166	1.22	Thread t = newStartedThread(task);
245			threadStarted.await();
246	jsr166	1.15	assertTrue(task.cancel(false));
247	jsr166	1.22	checkCancelled(task);
248			cancelled.countDown();
249			awaitTermination(t, MEDIUM_DELAY_MS);
250			checkCancelled(task);
251	dl	1.1	}
252
253	dl	1.5	/**
254	dl	1.6	* set in one thread causes get in another thread to retrieve value
255	dl	1.5	*/
256	jsr166	1.15	public void testGet1() throws InterruptedException {
257	jsr166	1.22	final FutureTask task =
258	jsr166	1.15	new FutureTask(new CheckedCallable<Object>() {
259	jsr166	1.16	public Object realCall() throws InterruptedException {
260	dl	1.1	return Boolean.TRUE;
261	jsr166	1.15	}});
262	jsr166	1.22	checkNotDone(task);
263
264			Thread t = newStartedThread(new CheckedRunnable() {
265	jsr166	1.15	public void realRun() throws Exception {
266	jsr166	1.22	assertSame(Boolean.TRUE, task.get());
267	jsr166	1.15	}});
268	dl	1.1
269	jsr166	1.22	task.run();
270			checkCompletedNormally(task, Boolean.TRUE);
271			awaitTermination(t, MEDIUM_DELAY_MS);
272	dl	1.1	}
273
274	dl	1.5	/**
275	dl	1.6	* set in one thread causes timed get in another thread to retrieve value
276	dl	1.5	*/
277	jsr166	1.15	public void testTimedGet1() throws InterruptedException {
278	jsr166	1.22	final FutureTask task =
279	jsr166	1.15	new FutureTask(new CheckedCallable<Object>() {
280	jsr166	1.16	public Object realCall() throws InterruptedException {
281	dl	1.1	return Boolean.TRUE;
282	jsr166	1.15	}});
283	jsr166	1.22	checkNotDone(task);
284
285			Thread t = newStartedThread(new CheckedRunnable() {
286	jsr166	1.15	public void realRun() throws Exception {
287	jsr166	1.22	assertSame(Boolean.TRUE, task.get(SMALL_DELAY_MS, MILLISECONDS));
288	jsr166	1.15	}});
289	jsr166	1.12
290	jsr166	1.22	task.run();
291			checkCompletedNormally(task, Boolean.TRUE);
292			awaitTermination(t, MEDIUM_DELAY_MS);
293	dl	1.1	}
294
295	dl	1.5	/**
296	jsr166	1.21	* Cancelling a task causes timed get in another thread to throw
297			* CancellationException
298	dl	1.5	*/
299	jsr166	1.15	public void testTimedGet_Cancellation() throws InterruptedException {
300	jsr166	1.22	final CountDownLatch threadStarted = new CountDownLatch(2);
301			final FutureTask task =
302	jsr166	1.15	new FutureTask(new CheckedInterruptedCallable<Object>() {
303	jsr166	1.16	public Object realCall() throws InterruptedException {
304	jsr166	1.22	threadStarted.countDown();
305			Thread.sleep(LONG_DELAY_MS);
306	jsr166	1.16	return Boolean.TRUE;
307	jsr166	1.15	}});
308
309			Thread t1 = new ThreadShouldThrow(CancellationException.class) {
310			public void realRun() throws Exception {
311	jsr166	1.22	threadStarted.countDown();
312			task.get(MEDIUM_DELAY_MS, MILLISECONDS);
313	jsr166	1.15	}};
314	jsr166	1.22	Thread t2 = new Thread(task);
315	jsr166	1.15	t1.start();
316			t2.start();
317	jsr166	1.22	threadStarted.await();
318			task.cancel(true);
319			awaitTermination(t1, MEDIUM_DELAY_MS);
320			awaitTermination(t2, MEDIUM_DELAY_MS);
321			checkCancelled(task);
322	dl	1.1	}
323	dl	1.6
324	dl	1.5	/**
325	jsr166	1.20	* Cancelling a task causes get in another thread to throw
326			* CancellationException
327	dl	1.5	*/
328	jsr166	1.15	public void testGet_Cancellation() throws InterruptedException {
329	jsr166	1.22	final CountDownLatch threadStarted = new CountDownLatch(2);
330			final FutureTask task =
331	jsr166	1.15	new FutureTask(new CheckedInterruptedCallable<Object>() {
332	jsr166	1.16	public Object realCall() throws InterruptedException {
333	jsr166	1.22	threadStarted.countDown();
334			Thread.sleep(LONG_DELAY_MS);
335	jsr166	1.16	return Boolean.TRUE;
336	jsr166	1.15	}});
337	jsr166	1.22
338	jsr166	1.15	Thread t1 = new ThreadShouldThrow(CancellationException.class) {
339			public void realRun() throws Exception {
340	jsr166	1.22	threadStarted.countDown();
341			task.get();
342	jsr166	1.15	}};
343	jsr166	1.22	Thread t2 = new Thread(task);
344	jsr166	1.15	t1.start();
345			t2.start();
346	jsr166	1.22	threadStarted.await();
347			task.cancel(true);
348			awaitTermination(t1, MEDIUM_DELAY_MS);
349			awaitTermination(t2, MEDIUM_DELAY_MS);
350			checkCancelled(task);
351	dl	1.1	}
352	jsr166	1.12
353	dl	1.1
354	dl	1.5	/**
355	dl	1.6	* A runtime exception in task causes get to throw ExecutionException
356	dl	1.5	*/
357	jsr166	1.15	public void testGet_ExecutionException() throws InterruptedException {
358	jsr166	1.22	final FutureTask task = new FutureTask(new Callable() {
359	jsr166	1.16	public Object call() {
360	jsr166	1.15	return 5/0;
361			}});
362
363	jsr166	1.22	task.run();
364	jsr166	1.15	try {
365	jsr166	1.22	task.get();
366	jsr166	1.17	shouldThrow();
367	jsr166	1.16	} catch (ExecutionException success) {
368	jsr166	1.15	assertTrue(success.getCause() instanceof ArithmeticException);
369	jsr166	1.22	checkCompletedAbnormally(task, success.getCause());
370	dl	1.1	}
371			}
372	jsr166	1.12
373	dl	1.5	/**
374	jsr166	1.20	* A runtime exception in task causes timed get to throw ExecutionException
375	dl	1.5	*/
376	jsr166	1.15	public void testTimedGet_ExecutionException2() throws Exception {
377	jsr166	1.22	final FutureTask task = new FutureTask(new Callable() {
378	jsr166	1.16	public Object call() {
379	jsr166	1.15	return 5/0;
380			}});
381
382	jsr166	1.22	task.run();
383	jsr166	1.16	try {
384	jsr166	1.22	task.get(SHORT_DELAY_MS, MILLISECONDS);
385	jsr166	1.17	shouldThrow();
386	jsr166	1.16	} catch (ExecutionException success) {
387	jsr166	1.15	assertTrue(success.getCause() instanceof ArithmeticException);
388	jsr166	1.22	checkCompletedAbnormally(task, success.getCause());
389	jsr166	1.15	}
390	dl	1.1	}
391	jsr166	1.12
392	dl	1.1
393	dl	1.5	/**
394	dl	1.6	* Interrupting a waiting get causes it to throw InterruptedException
395	dl	1.5	*/
396	jsr166	1.15	public void testGet_InterruptedException() throws InterruptedException {
397	jsr166	1.22	final CountDownLatch threadStarted = new CountDownLatch(1);
398			final FutureTask task = new FutureTask(new NoOpCallable());
399			Thread t = newStartedThread(new CheckedInterruptedRunnable() {
400	jsr166	1.15	public void realRun() throws Exception {
401	jsr166	1.22	threadStarted.countDown();
402			task.get();
403	jsr166	1.15	}});
404
405	jsr166	1.22	threadStarted.await();
406	jsr166	1.15	t.interrupt();
407	jsr166	1.22	awaitTermination(t, MEDIUM_DELAY_MS);
408			checkNotDone(task);
409	dl	1.1	}
410
411	dl	1.5	/**
412	jsr166	1.20	* Interrupting a waiting timed get causes it to throw InterruptedException
413	dl	1.5	*/
414	jsr166	1.15	public void testTimedGet_InterruptedException2() throws InterruptedException {
415	jsr166	1.22	final CountDownLatch threadStarted = new CountDownLatch(1);
416			final FutureTask task = new FutureTask(new NoOpCallable());
417			Thread t = newStartedThread(new CheckedInterruptedRunnable() {
418	jsr166	1.15	public void realRun() throws Exception {
419	jsr166	1.22	threadStarted.countDown();
420			task.get(LONG_DELAY_MS, MILLISECONDS);
421	jsr166	1.15	}});
422
423	jsr166	1.22	threadStarted.await();
424	jsr166	1.15	t.interrupt();
425	jsr166	1.22	awaitTermination(t, MEDIUM_DELAY_MS);
426			checkNotDone(task);
427	dl	1.1	}
428	jsr166	1.12
429	dl	1.5	/**
430	dl	1.6	* A timed out timed get throws TimeoutException
431	dl	1.5	*/
432	jsr166	1.15	public void testGet_TimeoutException() throws Exception {
433	jsr166	1.16	try {
434	jsr166	1.22	FutureTask task = new FutureTask(new NoOpCallable());
435			task.get(1, MILLISECONDS);
436	jsr166	1.17	shouldThrow();
437	jsr166	1.16	} catch (TimeoutException success) {}
438	dl	1.1	}
439	jsr166	1.12
440	dl	1.1	}