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

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.22

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8