[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.4, Sun Sep 14 20:42:40 2003 UTC revision 1.11, Mon Dec 29 19:05:40 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.*;
# Line 21  Line 22 
22      /**      /**
23       * Subclass to expose protected methods       * Subclass to expose protected methods
24       */       */
25      static class MyFutureTask extends FutureTask {      static class PublicFutureTask extends FutureTask {
26          public MyFutureTask(Callable r) { super(r); }          public PublicFutureTask(Callable r) { super(r); }
27          public boolean reset() { return super.reset(); }          public boolean runAndReset() { return super.runAndReset(); }
         public void setCancelled() { super.setCancelled(); }  
         public void setDone() { super.setDone(); }  
28          public void set(Object x) { super.set(x); }          public void set(Object x) { super.set(x); }
29          public void setException(Throwable t) { super.setException(t); }          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(){      public void testConstructor(){
36          try {          try {
37              FutureTask task = new FutureTask(null);              FutureTask task = new FutureTask(null);
38              fail("should throw");              shouldThrow();
39          }          }
40          catch(NullPointerException success) {          catch(NullPointerException success) {
41          }          }
42      }      }
43    
44        /**
45         * creating a future with null runnable fails
46         */
47      public void testConstructor2(){      public void testConstructor2(){
48          try {          try {
49              FutureTask task = new FutureTask(null, Boolean.TRUE);              FutureTask task = new FutureTask(null, Boolean.TRUE);
50              fail("should throw");              shouldThrow();
51          }          }
52          catch(NullPointerException success) {          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 NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
61          task.run();          task.run();
# Line 55  Line 63 
63          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
64      }      }
65    
66      public void testReset(){      /**
67          MyFutureTask task = new MyFutureTask(new NoOpCallable());       * runAndReset of a non-cancelled task succeeds
68          task.run();       */
69          assertTrue(task.isDone());      public void testRunAndReset() {
70          assertTrue(task.reset());          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() {      public void testResetAfterCancel() {
79          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
80          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
81          task.run();          assertFalse(task.runAndReset());
82          assertTrue(task.isDone());          assertTrue(task.isDone());
83          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
         assertFalse(task.reset());  
84      }      }
85    
     public void testSetDone() {  
         MyFutureTask task = new MyFutureTask(new NoOpCallable());  
         task.setDone();  
         assertTrue(task.isDone());  
         assertFalse(task.isCancelled());  
     }  
86    
     public void testSetCancelled() {  
         MyFutureTask task = new MyFutureTask(new NoOpCallable());  
         assertTrue(task.cancel(false));  
         task.setCancelled();  
         assertTrue(task.isDone());  
         assertTrue(task.isCancelled());  
     }  
87    
88        /**
89         * setting value causes get to return it
90         */
91      public void testSet() {      public void testSet() {
92          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
93          task.set(one);          task.set(one);
94          try {          try {
95              assertEquals(task.get(), one);              assertEquals(task.get(), one);
96          }          }
97          catch(Exception e) {          catch(Exception e) {
98              fail("unexpected exception");              unexpectedException();
99          }          }
100      }      }
101    
102        /**
103         * setException causes get to throw ExecutionException
104         */
105      public void testSetException() {      public void testSetException() {
106          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
107          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
108          task.setException(nse);          task.setException(nse);
109          try {          try {
110              Object x = task.get();              Object x = task.get();
111              fail("should throw");              shouldThrow();
112          }          }
113          catch(ExecutionException ee) {          catch(ExecutionException ee) {
114              Throwable cause = ee.getCause();              Throwable cause = ee.getCause();
115              assertEquals(cause, nse);              assertEquals(cause, nse);
116          }          }
117          catch(Exception e) {          catch(Exception e) {
118              fail("unexpected exception");              unexpectedException();
119          }          }
120      }      }
121    
122        /**
123         *  Cancelling before running succeeds
124         */
125      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
126          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
127          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
# Line 122  Line 130 
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 NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
138          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
# Line 130  Line 141 
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 NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
149          task.run();          task.run();
# Line 138  Line 152 
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(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
163                          threadFail("should throw");                          threadShouldThrow();
164                      }                      }
165                      catch (InterruptedException success) {}                      catch (InterruptedException success) {}
166                      return Boolean.TRUE;                      return Boolean.TRUE;
# Line 158  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() {
# Line 184  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                          threadFail("unexpected exception");                          threadUnexpectedException();
221                      }                      }
222                      return Boolean.TRUE;                      return Boolean.TRUE;
223                  }                  }
# Line 204  Line 227 
227                      try{                      try{
228                          ft.get();                          ft.get();
229                      } catch(Exception e){                      } catch(Exception e){
230                          threadFail("unexpected exception");                          threadUnexpectedException();
231                      }                      }
232                  }                  }
233              });              });
# Line 218  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                          threadFail("unexpected exception");                          threadUnexpectedException();
259                      }                      }
260                      return Boolean.TRUE;                      return Boolean.TRUE;
261                  }                  }
# Line 240  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                          threadFail("unexpected exception");                          threadUnexpectedException();
270                      }                      }
271                  }                  }
272              });              });
# Line 253  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){
                         threadFail("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                              threadFail("should throw");                              threadShouldThrow();
307                          } catch(CancellationException success){                          } catch(CancellationException success) {}
                         }  
308                          catch(Exception e){                          catch(Exception e){
309                              threadFail("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 success){              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) {
                         threadFail("unexpected exception");  
335                      }                      }
336                      return Boolean.TRUE;                      return Boolean.TRUE;
337                  }                  }
338              });              });
339          try{          try{
340              Thread.sleep(SHORT_DELAY_MS);              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(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);                              ft.get();
344                              threadFail("should throw");                              threadShouldThrow();
345                          } catch(CancellationException success) {}                          } catch(CancellationException success){
346                            }
347                          catch(Exception e){                          catch(Exception e){
348                              threadFail("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 336  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 354  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 NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
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                          threadFail("should throw");                          threadShouldThrow();
418                      } catch(InterruptedException success){                      } catch(InterruptedException success){
419                      } catch(Exception e){                      } catch(Exception e){
420                          threadFail("unexpected exception");                          threadUnexpectedException();
421                      }                      }
422                  }                  }
423              });              });
# Line 382  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 NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
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(LONG_DELAY_MS,TimeUnit.MILLISECONDS);                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
443                          threadFail("should throw");                          threadShouldThrow();
444                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
445                      catch(Exception e){                      catch(Exception e){
446                          threadFail("unexpected exception");                          threadUnexpectedException();
447                      }                      }
448                  }                  }
449              });              });
# Line 405  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(){
464          try{          try{
465              FutureTask ft = new FutureTask(new NoOpCallable());              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 success){          catch(Exception success){
470              fail("unexpected exception");              unexpectedException();
471          }          }
472      }      }
473    

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.11

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8