[cvs] / jsr166 / src / test / tck / FutureTaskTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/FutureTaskTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.34 - (view) (download)

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 : jsr166 1.24 * http://creativecommons.org/publicdomain/zero/1.0/
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 : jsr166 1.26 import java.util.concurrent.Callable;
11 :     import java.util.concurrent.CancellationException;
12 :     import java.util.concurrent.CountDownLatch;
13 :     import java.util.concurrent.ExecutionException;
14 :     import java.util.concurrent.Future;
15 :     import java.util.concurrent.FutureTask;
16 :     import java.util.concurrent.TimeoutException;
17 : jsr166 1.29 import java.util.concurrent.atomic.AtomicInteger;
18 : jsr166 1.15 import static java.util.concurrent.TimeUnit.MILLISECONDS;
19 : jsr166 1.22 import static java.util.concurrent.TimeUnit.SECONDS;
20 : dl 1.4 import java.util.*;
21 : dl 1.1
22 : dl 1.4 public class FutureTaskTest extends JSR166TestCase {
23 : dl 1.1
24 :     public static void main(String[] args) {
25 : jsr166 1.19 junit.textui.TestRunner.run(suite());
26 : dl 1.1 }
27 :     public static Test suite() {
28 : jsr166 1.16 return new TestSuite(FutureTaskTest.class);
29 : dl 1.1 }
30 :    
31 : jsr166 1.29 void checkIsDone(Future<?> f) {
32 :     assertTrue(f.isDone());
33 :     assertFalse(f.cancel(false));
34 :     assertFalse(f.cancel(true));
35 :     if (f instanceof PublicFutureTask) {
36 :     PublicFutureTask pf = (PublicFutureTask) f;
37 :     assertEquals(1, pf.doneCount());
38 :     assertFalse(pf.runAndReset());
39 :     assertEquals(1, pf.doneCount());
40 :    
41 :     // Check that run and runAndReset have no effect.
42 :     int savedRunCount = pf.runCount();
43 :     int savedSetCount = pf.setCount();
44 :     int savedSetExceptionCount = pf.setExceptionCount();
45 :     pf.run();
46 :     pf.runAndReset();
47 :     assertEquals(savedRunCount, pf.runCount());
48 :     assertEquals(savedSetCount, pf.setCount());
49 :     assertEquals(savedSetExceptionCount, pf.setExceptionCount());
50 :     assertTrue(f.isDone());
51 :     }
52 :     }
53 :    
54 : jsr166 1.22 void checkNotDone(Future<?> f) {
55 :     assertFalse(f.isDone());
56 :     assertFalse(f.isCancelled());
57 : jsr166 1.29 if (f instanceof PublicFutureTask) {
58 :     PublicFutureTask pf = (PublicFutureTask) f;
59 :     assertEquals(0, pf.doneCount());
60 :     assertEquals(0, pf.setCount());
61 :     assertEquals(0, pf.setExceptionCount());
62 :     }
63 :     }
64 :    
65 :     void checkIsRunning(Future<?> f) {
66 :     checkNotDone(f);
67 :     if (f instanceof FutureTask) {
68 :     FutureTask ft = (FutureTask<?>) f;
69 :     // Check that run methods do nothing
70 :     ft.run();
71 :     if (f instanceof PublicFutureTask)
72 :     assertFalse(((PublicFutureTask) f).runAndReset());
73 :     checkNotDone(f);
74 :     }
75 : jsr166 1.22 }
76 :    
77 :     <T> void checkCompletedNormally(Future<T> f, T expected) {
78 : jsr166 1.29 checkIsDone(f);
79 : jsr166 1.22 assertFalse(f.isCancelled());
80 :    
81 :     try {
82 :     assertSame(expected, f.get());
83 :     } catch (Throwable fail) { threadUnexpectedException(fail); }
84 :     try {
85 :     assertSame(expected, f.get(5L, SECONDS));
86 :     } catch (Throwable fail) { threadUnexpectedException(fail); }
87 :     }
88 :    
89 :     void checkCancelled(Future<?> f) {
90 : jsr166 1.29 checkIsDone(f);
91 : jsr166 1.22 assertTrue(f.isCancelled());
92 :    
93 :     try {
94 :     f.get();
95 :     shouldThrow();
96 :     } catch (CancellationException success) {
97 :     } catch (Throwable fail) { threadUnexpectedException(fail); }
98 :    
99 :     try {
100 :     f.get(5L, SECONDS);
101 :     shouldThrow();
102 :     } catch (CancellationException success) {
103 :     } catch (Throwable fail) { threadUnexpectedException(fail); }
104 : jsr166 1.29 }
105 : jsr166 1.22
106 : jsr166 1.29 void tryToConfuseDoneTask(PublicFutureTask pf) {
107 :     pf.set(new Object());
108 :     pf.setException(new Error());
109 :     for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
110 :     pf.cancel(true);
111 :     }
112 : jsr166 1.22 }
113 :    
114 :     void checkCompletedAbnormally(Future<?> f, Throwable t) {
115 : jsr166 1.29 checkIsDone(f);
116 : jsr166 1.22 assertFalse(f.isCancelled());
117 :    
118 :     try {
119 :     f.get();
120 :     shouldThrow();
121 :     } catch (ExecutionException success) {
122 :     assertSame(t, success.getCause());
123 :     } catch (Throwable fail) { threadUnexpectedException(fail); }
124 :    
125 :     try {
126 :     f.get(5L, SECONDS);
127 :     shouldThrow();
128 :     } catch (ExecutionException success) {
129 :     assertSame(t, success.getCause());
130 :     } catch (Throwable fail) { threadUnexpectedException(fail); }
131 :     }
132 :    
133 : dl 1.4 /**
134 :     * Subclass to expose protected methods
135 :     */
136 : dl 1.7 static class PublicFutureTask extends FutureTask {
137 : jsr166 1.29 private final AtomicInteger runCount;
138 :     private final AtomicInteger doneCount = new AtomicInteger(0);
139 :     private final AtomicInteger runAndResetCount = new AtomicInteger(0);
140 :     private final AtomicInteger setCount = new AtomicInteger(0);
141 :     private final AtomicInteger setExceptionCount = new AtomicInteger(0);
142 :     public int runCount() { return runCount.get(); }
143 :     public int doneCount() { return doneCount.get(); }
144 :     public int runAndResetCount() { return runAndResetCount.get(); }
145 :     public int setCount() { return setCount.get(); }
146 :     public int setExceptionCount() { return setExceptionCount.get(); }
147 :    
148 :     PublicFutureTask(Runnable runnable) {
149 :     this(runnable, seven);
150 :     }
151 :     PublicFutureTask(Runnable runnable, Object result) {
152 :     this(runnable, result, new AtomicInteger(0));
153 :     }
154 :     private PublicFutureTask(final Runnable runnable, Object result,
155 :     final AtomicInteger runCount) {
156 :     super(new Runnable() {
157 : jsr166 1.31 public void run() {
158 :     runCount.getAndIncrement();
159 :     runnable.run();
160 :     }}, result);
161 : jsr166 1.29 this.runCount = runCount;
162 :     }
163 :     PublicFutureTask(Callable callable) {
164 :     this(callable, new AtomicInteger(0));
165 :     }
166 :     private PublicFutureTask(final Callable callable,
167 :     final AtomicInteger runCount) {
168 :     super(new Callable() {
169 :     public Object call() throws Exception {
170 :     runCount.getAndIncrement();
171 :     return callable.call();
172 :     }});
173 :     this.runCount = runCount;
174 :     }
175 : jsr166 1.30 @Override public void done() {
176 : jsr166 1.29 assertTrue(isDone());
177 :     doneCount.incrementAndGet();
178 :     super.done();
179 :     }
180 : jsr166 1.30 @Override public boolean runAndReset() {
181 : jsr166 1.29 runAndResetCount.incrementAndGet();
182 :     return super.runAndReset();
183 :     }
184 : jsr166 1.30 @Override public void set(Object x) {
185 : jsr166 1.29 setCount.incrementAndGet();
186 :     super.set(x);
187 :     }
188 : jsr166 1.30 @Override public void setException(Throwable t) {
189 : jsr166 1.29 setExceptionCount.incrementAndGet();
190 :     super.setException(t);
191 :     }
192 :     }
193 :    
194 :     class Counter extends CheckedRunnable {
195 :     final AtomicInteger count = new AtomicInteger(0);
196 :     public int get() { return count.get(); }
197 :     public void realRun() {
198 :     count.getAndIncrement();
199 :     }
200 : dl 1.4 }
201 : dl 1.1
202 : dl 1.5 /**
203 : jsr166 1.29 * creating a future with a null callable throws NullPointerException
204 : dl 1.5 */
205 :     public void testConstructor() {
206 : dl 1.3 try {
207 : jsr166 1.29 new FutureTask(null);
208 : jsr166 1.17 shouldThrow();
209 : jsr166 1.15 } catch (NullPointerException success) {}
210 : dl 1.3 }
211 :    
212 : dl 1.5 /**
213 : jsr166 1.29 * creating a future with null runnable throws NullPointerException
214 : dl 1.5 */
215 :     public void testConstructor2() {
216 : dl 1.3 try {
217 : jsr166 1.29 new FutureTask(null, Boolean.TRUE);
218 : jsr166 1.17 shouldThrow();
219 : jsr166 1.15 } catch (NullPointerException success) {}
220 : dl 1.3 }
221 :    
222 : dl 1.5 /**
223 : dl 1.6 * isDone is true when a task completes
224 : dl 1.5 */
225 :     public void testIsDone() {
226 : jsr166 1.29 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
227 :     assertFalse(task.isDone());
228 : jsr166 1.16 task.run();
229 :     assertTrue(task.isDone());
230 : jsr166 1.22 checkCompletedNormally(task, Boolean.TRUE);
231 : jsr166 1.29 assertEquals(1, task.runCount());
232 : dl 1.4 }
233 :    
234 : dl 1.5 /**
235 : dl 1.9 * runAndReset of a non-cancelled task succeeds
236 : dl 1.5 */
237 : dl 1.9 public void testRunAndReset() {
238 : dl 1.7 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
239 : jsr166 1.29 for (int i = 0; i < 3; i++) {
240 :     assertTrue(task.runAndReset());
241 :     checkNotDone(task);
242 :     assertEquals(i+1, task.runCount());
243 :     assertEquals(i+1, task.runAndResetCount());
244 :     assertEquals(0, task.setCount());
245 :     assertEquals(0, task.setExceptionCount());
246 :     }
247 : dl 1.4 }
248 :    
249 : dl 1.5 /**
250 : dl 1.9 * runAndReset after cancellation fails
251 : dl 1.5 */
252 : jsr166 1.29 public void testRunAndResetAfterCancel() {
253 :     for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
254 :     PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
255 :     assertTrue(task.cancel(mayInterruptIfRunning));
256 :     for (int i = 0; i < 3; i++) {
257 :     assertFalse(task.runAndReset());
258 :     assertEquals(0, task.runCount());
259 :     assertEquals(i+1, task.runAndResetCount());
260 :     assertEquals(0, task.setCount());
261 :     assertEquals(0, task.setExceptionCount());
262 :     }
263 :     tryToConfuseDoneTask(task);
264 :     checkCancelled(task);
265 :     }
266 : dl 1.4 }
267 :    
268 : dl 1.5 /**
269 : dl 1.11 * setting value causes get to return it
270 : dl 1.5 */
271 : jsr166 1.15 public void testSet() throws Exception {
272 : dl 1.7 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
273 : dl 1.4 task.set(one);
274 : jsr166 1.29 for (int i = 0; i < 3; i++) {
275 :     assertSame(one, task.get());
276 :     assertSame(one, task.get(LONG_DELAY_MS, MILLISECONDS));
277 :     assertEquals(1, task.setCount());
278 :     }
279 :     tryToConfuseDoneTask(task);
280 : jsr166 1.22 checkCompletedNormally(task, one);
281 : jsr166 1.29 assertEquals(0, task.runCount());
282 : dl 1.4 }
283 :    
284 : dl 1.5 /**
285 : dl 1.6 * setException causes get to throw ExecutionException
286 : dl 1.5 */
287 : jsr166 1.29 public void testSetException_get() throws Exception {
288 : dl 1.4 Exception nse = new NoSuchElementException();
289 : dl 1.7 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
290 : dl 1.4 task.setException(nse);
291 : jsr166 1.29
292 :     try {
293 :     task.get();
294 :     shouldThrow();
295 :     } catch (ExecutionException success) {
296 :     assertSame(nse, success.getCause());
297 :     checkCompletedAbnormally(task, nse);
298 :     }
299 :    
300 : dl 1.4 try {
301 : jsr166 1.29 task.get(LONG_DELAY_MS, MILLISECONDS);
302 : jsr166 1.17 shouldThrow();
303 : jsr166 1.15 } catch (ExecutionException success) {
304 : jsr166 1.29 assertSame(nse, success.getCause());
305 : jsr166 1.22 checkCompletedAbnormally(task, nse);
306 : dl 1.4 }
307 : jsr166 1.29
308 :     assertEquals(1, task.setExceptionCount());
309 :     assertEquals(0, task.setCount());
310 :     tryToConfuseDoneTask(task);
311 :     checkCompletedAbnormally(task, nse);
312 :     assertEquals(0, task.runCount());
313 : dl 1.4 }
314 :    
315 : dl 1.5 /**
316 : jsr166 1.29 * cancel(false) before run succeeds
317 : dl 1.5 */
318 : dl 1.1 public void testCancelBeforeRun() {
319 : jsr166 1.29 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
320 : dl 1.1 assertTrue(task.cancel(false));
321 : jsr166 1.16 task.run();
322 : jsr166 1.32 assertEquals(0, task.runCount());
323 : jsr166 1.29 assertEquals(0, task.setCount());
324 :     assertEquals(0, task.setExceptionCount());
325 : jsr166 1.32 assertTrue(task.isCancelled());
326 :     assertTrue(task.isDone());
327 : jsr166 1.29 tryToConfuseDoneTask(task);
328 : jsr166 1.32 assertEquals(0, task.runCount());
329 : jsr166 1.22 checkCancelled(task);
330 : dl 1.1 }
331 :    
332 : dl 1.5 /**
333 : jsr166 1.29 * cancel(true) before run succeeds
334 : dl 1.5 */
335 : dl 1.1 public void testCancelBeforeRun2() {
336 : jsr166 1.29 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
337 : dl 1.1 assertTrue(task.cancel(true));
338 : jsr166 1.16 task.run();
339 : jsr166 1.32 assertEquals(0, task.runCount());
340 : jsr166 1.29 assertEquals(0, task.setCount());
341 :     assertEquals(0, task.setExceptionCount());
342 : jsr166 1.32 assertTrue(task.isCancelled());
343 :     assertTrue(task.isDone());
344 : jsr166 1.29 tryToConfuseDoneTask(task);
345 : jsr166 1.32 assertEquals(0, task.runCount());
346 : jsr166 1.22 checkCancelled(task);
347 : dl 1.1 }
348 :    
349 : dl 1.5 /**
350 : jsr166 1.29 * cancel(false) of a completed task fails
351 : dl 1.5 */
352 : dl 1.1 public void testCancelAfterRun() {
353 : jsr166 1.29 PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
354 : jsr166 1.16 task.run();
355 : dl 1.1 assertFalse(task.cancel(false));
356 : jsr166 1.32 assertEquals(1, task.runCount());
357 : jsr166 1.29 assertEquals(1, task.setCount());
358 :     assertEquals(0, task.setExceptionCount());
359 :     tryToConfuseDoneTask(task);
360 :     checkCompletedNormally(task, Boolean.TRUE);
361 :     assertEquals(1, task.runCount());
362 :     }
363 :    
364 :     /**
365 :     * cancel(true) of a completed task fails
366 :     */
367 :     public void testCancelAfterRun2() {
368 :     PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
369 :     task.run();
370 :     assertFalse(task.cancel(true));
371 : jsr166 1.32 assertEquals(1, task.runCount());
372 : jsr166 1.29 assertEquals(1, task.setCount());
373 :     assertEquals(0, task.setExceptionCount());
374 :     tryToConfuseDoneTask(task);
375 : jsr166 1.22 checkCompletedNormally(task, Boolean.TRUE);
376 : jsr166 1.29 assertEquals(1, task.runCount());
377 : dl 1.1 }
378 :    
379 : dl 1.5 /**
380 : jsr166 1.29 * cancel(true) interrupts a running task that subsequently succeeds
381 : dl 1.5 */
382 : jsr166 1.29 public void testCancelInterrupt() {
383 :     final CountDownLatch pleaseCancel = new CountDownLatch(1);
384 :     final PublicFutureTask task =
385 :     new PublicFutureTask(new CheckedRunnable() {
386 :     public void realRun() {
387 :     pleaseCancel.countDown();
388 :     try {
389 :     delay(LONG_DELAY_MS);
390 :     shouldThrow();
391 :     } catch (InterruptedException success) {}
392 : jsr166 1.15 }});
393 :    
394 : jsr166 1.22 Thread t = newStartedThread(task);
395 : jsr166 1.29 await(pleaseCancel);
396 : jsr166 1.15 assertTrue(task.cancel(true));
397 : jsr166 1.29 assertTrue(task.isCancelled());
398 : jsr166 1.32 assertTrue(task.isDone());
399 : jsr166 1.29 awaitTermination(t);
400 :     assertEquals(1, task.runCount());
401 :     assertEquals(1, task.setCount());
402 :     assertEquals(0, task.setExceptionCount());
403 :     tryToConfuseDoneTask(task);
404 : jsr166 1.22 checkCancelled(task);
405 : jsr166 1.29 }
406 :    
407 :     /**
408 : jsr166 1.33 * cancel(true) tries to interrupt a running task, but
409 :     * Thread.interrupt throws (simulating a restrictive security
410 :     * manager)
411 : jsr166 1.32 */
412 :     public void testCancelInterrupt_ThrowsSecurityException() {
413 :     final CountDownLatch pleaseCancel = new CountDownLatch(1);
414 :     final CountDownLatch cancelled = new CountDownLatch(1);
415 :     final PublicFutureTask task =
416 :     new PublicFutureTask(new CheckedRunnable() {
417 :     public void realRun() {
418 :     pleaseCancel.countDown();
419 :     await(cancelled);
420 :     assertFalse(Thread.interrupted());
421 :     }});
422 :    
423 : jsr166 1.33 final Thread t = new Thread(task) {
424 :     // Simulate a restrictive security manager.
425 :     @Override public void interrupt() {
426 :     throw new SecurityException();
427 :     }};
428 :     t.setDaemon(true);
429 :     t.start();
430 :    
431 : jsr166 1.32 await(pleaseCancel);
432 :     try {
433 : jsr166 1.33 task.cancel(true);
434 :     shouldThrow();
435 :     } catch (SecurityException expected) {}
436 :    
437 :     // We failed to deliver the interrupt, but the world retains
438 :     // its sanity, as if we had done task.cancel(false)
439 : jsr166 1.32 assertTrue(task.isCancelled());
440 :     assertTrue(task.isDone());
441 :     assertEquals(1, task.runCount());
442 :     assertEquals(1, task.doneCount());
443 :     assertEquals(0, task.setCount());
444 :     assertEquals(0, task.setExceptionCount());
445 :     cancelled.countDown();
446 :     awaitTermination(t);
447 :     assertEquals(1, task.setCount());
448 :     assertEquals(0, task.setExceptionCount());
449 :     tryToConfuseDoneTask(task);
450 :     checkCancelled(task);
451 :     }
452 :    
453 :     /**
454 : jsr166 1.29 * cancel(true) interrupts a running task that subsequently throws
455 :     */
456 :     public void testCancelInterrupt_taskFails() {
457 :     final CountDownLatch pleaseCancel = new CountDownLatch(1);
458 :     final PublicFutureTask task =
459 :     new PublicFutureTask(new Runnable() {
460 :     public void run() {
461 :     try {
462 :     pleaseCancel.countDown();
463 :     delay(LONG_DELAY_MS);
464 :     } finally { throw new RuntimeException(); }
465 :     }});
466 :    
467 :     Thread t = newStartedThread(task);
468 :     await(pleaseCancel);
469 :     assertTrue(task.cancel(true));
470 :     assertTrue(task.isCancelled());
471 :     awaitTermination(t);
472 :     assertEquals(1, task.runCount());
473 :     assertEquals(0, task.setCount());
474 :     assertEquals(1, task.setExceptionCount());
475 :     tryToConfuseDoneTask(task);
476 : jsr166 1.22 checkCancelled(task);
477 : dl 1.1 }
478 :    
479 : dl 1.5 /**
480 : dl 1.6 * cancel(false) does not interrupt a running task
481 : dl 1.5 */
482 : jsr166 1.29 public void testCancelNoInterrupt() {
483 :     final CountDownLatch pleaseCancel = new CountDownLatch(1);
484 : jsr166 1.22 final CountDownLatch cancelled = new CountDownLatch(1);
485 : jsr166 1.29 final PublicFutureTask task =
486 :     new PublicFutureTask(new CheckedCallable<Boolean>() {
487 :     public Boolean realCall() {
488 :     pleaseCancel.countDown();
489 :     await(cancelled);
490 : jsr166 1.22 assertFalse(Thread.interrupted());
491 : dl 1.1 return Boolean.TRUE;
492 : jsr166 1.15 }});
493 :    
494 : jsr166 1.22 Thread t = newStartedThread(task);
495 : jsr166 1.29 await(pleaseCancel);
496 : jsr166 1.15 assertTrue(task.cancel(false));
497 : jsr166 1.29 assertTrue(task.isCancelled());
498 : jsr166 1.22 cancelled.countDown();
499 : jsr166 1.29 awaitTermination(t);
500 :     assertEquals(1, task.runCount());
501 :     assertEquals(1, task.setCount());
502 :     assertEquals(0, task.setExceptionCount());
503 :     tryToConfuseDoneTask(task);
504 : jsr166 1.22 checkCancelled(task);
505 : dl 1.1 }
506 :    
507 : dl 1.5 /**
508 : jsr166 1.23 * run in one thread causes get in another thread to retrieve value
509 : dl 1.5 */
510 : jsr166 1.29 public void testGetRun() {
511 :     final CountDownLatch pleaseRun = new CountDownLatch(2);
512 : jsr166 1.23
513 :     final PublicFutureTask task =
514 :     new PublicFutureTask(new CheckedCallable<Object>() {
515 : jsr166 1.29 public Object realCall() {
516 :     return two;
517 : jsr166 1.23 }});
518 :    
519 : jsr166 1.29 Thread t1 = newStartedThread(new CheckedRunnable() {
520 : jsr166 1.23 public void realRun() throws Exception {
521 : jsr166 1.29 pleaseRun.countDown();
522 :     assertSame(two, task.get());
523 : jsr166 1.23 }});
524 :    
525 : jsr166 1.29 Thread t2 = newStartedThread(new CheckedRunnable() {
526 : jsr166 1.15 public void realRun() throws Exception {
527 : jsr166 1.29 pleaseRun.countDown();
528 :     assertSame(two, task.get(2*LONG_DELAY_MS, MILLISECONDS));
529 : jsr166 1.15 }});
530 : jsr166 1.12
531 : jsr166 1.29 await(pleaseRun);
532 : jsr166 1.23 checkNotDone(task);
533 : jsr166 1.29 assertTrue(t1.isAlive());
534 :     assertTrue(t2.isAlive());
535 : jsr166 1.22 task.run();
536 : jsr166 1.29 checkCompletedNormally(task, two);
537 :     assertEquals(1, task.runCount());
538 :     assertEquals(1, task.setCount());
539 :     assertEquals(0, task.setExceptionCount());
540 :     awaitTermination(t1);
541 :     awaitTermination(t2);
542 :     tryToConfuseDoneTask(task);
543 :     checkCompletedNormally(task, two);
544 : dl 1.1 }
545 :    
546 : dl 1.5 /**
547 : jsr166 1.29 * set in one thread causes get in another thread to retrieve value
548 : jsr166 1.23 */
549 : jsr166 1.29 public void testGetSet() {
550 :     final CountDownLatch pleaseSet = new CountDownLatch(2);
551 : jsr166 1.23
552 :     final PublicFutureTask task =
553 :     new PublicFutureTask(new CheckedCallable<Object>() {
554 :     public Object realCall() throws InterruptedException {
555 : jsr166 1.29 return two;
556 : jsr166 1.23 }});
557 :    
558 : jsr166 1.29 Thread t1 = newStartedThread(new CheckedRunnable() {
559 :     public void realRun() throws Exception {
560 :     pleaseSet.countDown();
561 :     assertSame(two, task.get());
562 :     }});
563 :    
564 :     Thread t2 = newStartedThread(new CheckedRunnable() {
565 : jsr166 1.23 public void realRun() throws Exception {
566 : jsr166 1.29 pleaseSet.countDown();
567 :     assertSame(two, task.get(2*LONG_DELAY_MS, MILLISECONDS));
568 : jsr166 1.23 }});
569 :    
570 : jsr166 1.29 await(pleaseSet);
571 : jsr166 1.23 checkNotDone(task);
572 : jsr166 1.29 assertTrue(t1.isAlive());
573 :     assertTrue(t2.isAlive());
574 :     task.set(two);
575 :     assertEquals(0, task.runCount());
576 :     assertEquals(1, task.setCount());
577 :     assertEquals(0, task.setExceptionCount());
578 :     tryToConfuseDoneTask(task);
579 :     checkCompletedNormally(task, two);
580 :     awaitTermination(t1);
581 :     awaitTermination(t2);
582 : jsr166 1.23 }
583 :    
584 :     /**
585 : jsr166 1.21 * Cancelling a task causes timed get in another thread to throw
586 :     * CancellationException
587 : dl 1.5 */
588 : jsr166 1.29 public void testTimedGet_Cancellation() {
589 :     for (final boolean mayInterruptIfRunning :
590 :     new boolean[] { true, false }) {
591 :     final CountDownLatch pleaseCancel = new CountDownLatch(3);
592 :     final CountDownLatch cancelled = new CountDownLatch(1);
593 :     final PublicFutureTask task =
594 :     new PublicFutureTask(new CheckedCallable<Object>() {
595 :     public Object realCall() throws InterruptedException {
596 :     pleaseCancel.countDown();
597 :     if (mayInterruptIfRunning) {
598 :     try {
599 :     delay(2*LONG_DELAY_MS);
600 :     } catch (InterruptedException success) {}
601 :     } else {
602 :     await(cancelled);
603 :     }
604 :     return two;
605 :     }});
606 :    
607 :     Thread t1 = new ThreadShouldThrow(CancellationException.class) {
608 :     public void realRun() throws Exception {
609 :     pleaseCancel.countDown();
610 :     task.get();
611 :     }};
612 :     Thread t2 = new ThreadShouldThrow(CancellationException.class) {
613 :     public void realRun() throws Exception {
614 :     pleaseCancel.countDown();
615 :     task.get(2*LONG_DELAY_MS, MILLISECONDS);
616 :     }};
617 :     t1.start();
618 :     t2.start();
619 :     Thread t3 = newStartedThread(task);
620 :     await(pleaseCancel);
621 :     checkIsRunning(task);
622 :     task.cancel(mayInterruptIfRunning);
623 :     checkCancelled(task);
624 :     awaitTermination(t1);
625 :     awaitTermination(t2);
626 :     cancelled.countDown();
627 :     awaitTermination(t3);
628 :     assertEquals(1, task.runCount());
629 :     assertEquals(1, task.setCount());
630 :     assertEquals(0, task.setExceptionCount());
631 :     tryToConfuseDoneTask(task);
632 :     checkCancelled(task);
633 :     }
634 : dl 1.1 }
635 : jsr166 1.12
636 : dl 1.5 /**
637 : dl 1.6 * A runtime exception in task causes get to throw ExecutionException
638 : dl 1.5 */
639 : jsr166 1.15 public void testGet_ExecutionException() throws InterruptedException {
640 : jsr166 1.29 final ArithmeticException e = new ArithmeticException();
641 :     final PublicFutureTask task = new PublicFutureTask(new Callable() {
642 : jsr166 1.16 public Object call() {
643 : jsr166 1.29 throw e;
644 : jsr166 1.15 }});
645 :    
646 : jsr166 1.22 task.run();
647 : jsr166 1.29 assertEquals(1, task.runCount());
648 :     assertEquals(0, task.setCount());
649 :     assertEquals(1, task.setExceptionCount());
650 : jsr166 1.15 try {
651 : jsr166 1.22 task.get();
652 : jsr166 1.17 shouldThrow();
653 : jsr166 1.16 } catch (ExecutionException success) {
654 : jsr166 1.29 assertSame(e, success.getCause());
655 :     tryToConfuseDoneTask(task);
656 : jsr166 1.22 checkCompletedAbnormally(task, success.getCause());
657 : dl 1.1 }
658 :     }
659 : jsr166 1.12
660 : dl 1.5 /**
661 : jsr166 1.20 * A runtime exception in task causes timed get to throw ExecutionException
662 : dl 1.5 */
663 : jsr166 1.15 public void testTimedGet_ExecutionException2() throws Exception {
664 : jsr166 1.29 final ArithmeticException e = new ArithmeticException();
665 :     final PublicFutureTask task = new PublicFutureTask(new Callable() {
666 : jsr166 1.16 public Object call() {
667 : jsr166 1.29 throw e;
668 : jsr166 1.15 }});
669 :    
670 : jsr166 1.22 task.run();
671 : jsr166 1.16 try {
672 : jsr166 1.29 task.get(LONG_DELAY_MS, MILLISECONDS);
673 : jsr166 1.17 shouldThrow();
674 : jsr166 1.16 } catch (ExecutionException success) {
675 : jsr166 1.29 assertSame(e, success.getCause());
676 :     tryToConfuseDoneTask(task);
677 : jsr166 1.22 checkCompletedAbnormally(task, success.getCause());
678 : jsr166 1.15 }
679 : dl 1.1 }
680 : jsr166 1.12
681 : dl 1.5 /**
682 : jsr166 1.29 * get is interruptible
683 : dl 1.5 */
684 : jsr166 1.29 public void testGet_interruptible() {
685 :     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
686 : jsr166 1.22 final FutureTask task = new FutureTask(new NoOpCallable());
687 : jsr166 1.29 Thread t = newStartedThread(new CheckedRunnable() {
688 : jsr166 1.15 public void realRun() throws Exception {
689 : jsr166 1.29 Thread.currentThread().interrupt();
690 :     try {
691 :     task.get();
692 :     shouldThrow();
693 :     } catch (InterruptedException success) {}
694 :     assertFalse(Thread.interrupted());
695 :    
696 :     pleaseInterrupt.countDown();
697 :     try {
698 :     task.get();
699 :     shouldThrow();
700 :     } catch (InterruptedException success) {}
701 :     assertFalse(Thread.interrupted());
702 : jsr166 1.15 }});
703 :    
704 : jsr166 1.29 await(pleaseInterrupt);
705 : jsr166 1.15 t.interrupt();
706 : jsr166 1.28 awaitTermination(t);
707 : jsr166 1.22 checkNotDone(task);
708 : dl 1.1 }
709 :    
710 : dl 1.5 /**
711 : jsr166 1.29 * timed get is interruptible
712 : dl 1.5 */
713 : jsr166 1.29 public void testTimedGet_interruptible() {
714 :     final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
715 : jsr166 1.22 final FutureTask task = new FutureTask(new NoOpCallable());
716 : jsr166 1.29 Thread t = newStartedThread(new CheckedRunnable() {
717 : jsr166 1.15 public void realRun() throws Exception {
718 : jsr166 1.29 Thread.currentThread().interrupt();
719 :     try {
720 :     task.get(2*LONG_DELAY_MS, MILLISECONDS);
721 :     shouldThrow();
722 :     } catch (InterruptedException success) {}
723 :     assertFalse(Thread.interrupted());
724 :    
725 :     pleaseInterrupt.countDown();
726 :     try {
727 :     task.get(2*LONG_DELAY_MS, MILLISECONDS);
728 :     shouldThrow();
729 :     } catch (InterruptedException success) {}
730 :     assertFalse(Thread.interrupted());
731 : jsr166 1.15 }});
732 :    
733 : jsr166 1.29 await(pleaseInterrupt);
734 : jsr166 1.15 t.interrupt();
735 : jsr166 1.28 awaitTermination(t);
736 : jsr166 1.22 checkNotDone(task);
737 : dl 1.1 }
738 : jsr166 1.12
739 : dl 1.5 /**
740 : dl 1.6 * A timed out timed get throws TimeoutException
741 : dl 1.5 */
742 : jsr166 1.15 public void testGet_TimeoutException() throws Exception {
743 : jsr166 1.29 FutureTask task = new FutureTask(new NoOpCallable());
744 :     long startTime = System.nanoTime();
745 : jsr166 1.16 try {
746 : jsr166 1.29 task.get(timeoutMillis(), MILLISECONDS);
747 : jsr166 1.17 shouldThrow();
748 : jsr166 1.29 } catch (TimeoutException success) {
749 :     assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
750 :     }
751 :     }
752 :    
753 :     /**
754 :     * timed get with null TimeUnit throws NullPointerException
755 :     */
756 :     public void testGet_NullTimeUnit() throws Exception {
757 :     FutureTask task = new FutureTask(new NoOpCallable());
758 :     long[] timeouts = { Long.MIN_VALUE, 0L, Long.MAX_VALUE };
759 :    
760 :     for (long timeout : timeouts) {
761 :     try {
762 :     task.get(timeout, null);
763 :     shouldThrow();
764 :     } catch (NullPointerException success) {}
765 :     }
766 :    
767 :     task.run();
768 :    
769 :     for (long timeout : timeouts) {
770 :     try {
771 :     task.get(timeout, null);
772 :     shouldThrow();
773 :     } catch (NullPointerException success) {}
774 :     }
775 : dl 1.1 }
776 : jsr166 1.12
777 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8