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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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

Legend:
Removed from v.1.11  
changed lines
  Added in v.1.39

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8