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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8