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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8