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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8