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

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.32

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8