[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.5, Sat Sep 20 18:20:07 2003 UTC
# Line 7  Line 7 
7    
8  import junit.framework.*;  import junit.framework.*;
9  import java.util.concurrent.*;  import java.util.concurrent.*;
10    import java.util.*;
11    
12  public class FutureTaskTest extends TestCase {  public class FutureTaskTest extends JSR166TestCase {
13    
14      public static void main(String[] args) {      public static void main(String[] args) {
15          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
# Line 17  Line 18 
18          return new TestSuite(FutureTaskTest.class);          return new TestSuite(FutureTaskTest.class);
19      }      }
20    
21      private static long SHORT_DELAY_MS = 100;      /**
22      private static long MEDIUM_DELAY_MS = 1000;       * Subclass to expose protected methods
23      private static long LONG_DELAY_MS = 10000;       */
24        static class MyFutureTask extends FutureTask {
25            public MyFutureTask(Callable r) { super(r); }
26            public boolean reset() { return super.reset(); }
27            public void setCancelled() { super.setCancelled(); }
28            public void setDone() { super.setDone(); }
29            public void set(Object x) { super.set(x); }
30            public void setException(Throwable t) { super.setException(t); }
31        }
32    
33        /**
34         *
35         */
36        public void testConstructor() {
37            try {
38                FutureTask task = new FutureTask(null);
39                shouldThrow();
40            }
41            catch(NullPointerException success) {
42            }
43        }
44    
45        /**
46         *
47         */
48        public void testConstructor2() {
49            try {
50                FutureTask task = new FutureTask(null, Boolean.TRUE);
51                shouldThrow();
52            }
53            catch(NullPointerException success) {
54            }
55        }
56    
57        /**
58         *
59         */
60      public void testIsDone(){      public void testIsDone(){
61          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new NoOpCallable());
62                  public Object call() { return Boolean.TRUE; } });          task.run();
63            assertTrue(task.isDone());
64            assertFalse(task.isCancelled());
65        }
66    
67        /**
68         *
69         */
70        public void testReset() {
71            MyFutureTask task = new MyFutureTask(new NoOpCallable());
72            task.run();
73            assertTrue(task.isDone());
74            assertTrue(task.reset());
75        }
76    
77        /**
78         *
79         */
80        public void testResetAfterCancel() {
81            MyFutureTask task = new MyFutureTask(new NoOpCallable());
82            assertTrue(task.cancel(false));
83          task.run();          task.run();
84          assertTrue(task.isDone());          assertTrue(task.isDone());
85            assertTrue(task.isCancelled());
86            assertFalse(task.reset());
87        }
88    
89        /**
90         *
91         */
92        public void testSetDone() {
93            MyFutureTask task = new MyFutureTask(new NoOpCallable());
94            task.setDone();
95            assertTrue(task.isDone());
96          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
97      }      }
98    
99        /**
100         *
101         */
102        public void testSetCancelled() {
103            MyFutureTask task = new MyFutureTask(new NoOpCallable());
104            assertTrue(task.cancel(false));
105            task.setCancelled();
106            assertTrue(task.isDone());
107            assertTrue(task.isCancelled());
108        }
109    
110        /**
111         *
112         */
113        public void testSet() {
114            MyFutureTask task = new MyFutureTask(new NoOpCallable());
115            task.set(one);
116            try {
117                assertEquals(task.get(), one);
118            }
119            catch(Exception e) {
120                unexpectedException();
121            }
122        }
123    
124        /**
125         *
126         */
127        public void testSetException() {
128            Exception nse = new NoSuchElementException();
129            MyFutureTask task = new MyFutureTask(new NoOpCallable());
130            task.setException(nse);
131            try {
132                Object x = task.get();
133                shouldThrow();
134            }
135            catch(ExecutionException ee) {
136                Throwable cause = ee.getCause();
137                assertEquals(cause, nse);
138            }
139            catch(Exception e) {
140                unexpectedException();
141            }
142        }
143    
144        /**
145         *
146         */
147      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
148          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
149          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
150          task.run();          task.run();
151          assertTrue(task.isDone());          assertTrue(task.isDone());
152          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
153      }      }
154    
155        /**
156         *
157         */
158      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
159          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
160          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
161          task.run();          task.run();
162          assertTrue(task.isDone());          assertTrue(task.isDone());
163          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
164      }      }
165    
166        /**
167         *
168         */
169      public void testCancelAfterRun() {      public void testCancelAfterRun() {
170          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
171          task.run();          task.run();
172          assertFalse(task.cancel(false));          assertFalse(task.cancel(false));
173          assertTrue(task.isDone());          assertTrue(task.isDone());
174          assertFalse(task.isCancelled());          assertFalse(task.isCancelled());
175      }      }
176    
177        /**
178         *
179         */
180      public void testCancelInterrupt(){      public void testCancelInterrupt(){
181          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
182                  public Object call() {                  public Object call() {
183                      try {                      try {
184                          Thread.sleep(SHORT_DELAY_MS* 2);                          Thread.sleep(MEDIUM_DELAY_MS);
185                          fail("should throw");                          threadShouldThrow();
186                      }                      }
187                      catch (InterruptedException success) {}                      catch (InterruptedException success) {}
188                      return Boolean.TRUE;                      return Boolean.TRUE;
# Line 76  Line 197 
197              assertTrue(task.isDone());              assertTrue(task.isDone());
198              assertTrue(task.isCancelled());              assertTrue(task.isCancelled());
199          } catch(InterruptedException e){          } catch(InterruptedException e){
200              fail("unexpected exception");              unexpectedException();
201          }          }
202      }      }
203    
204    
205        /**
206         *
207         */
208      public void testCancelNoInterrupt(){      public void testCancelNoInterrupt(){
209          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
210                  public Object call() {                  public Object call() {
211                      try {                      try {
212                          Thread.sleep(SHORT_DELAY_MS* 2);                          Thread.sleep(MEDIUM_DELAY_MS);
213                      }                      }
214                      catch (InterruptedException success) {                      catch (InterruptedException success) {
215                          fail("should not interrupt");                          threadFail("should not interrupt");
216                      }                      }
217                      return Boolean.TRUE;                      return Boolean.TRUE;
218                  } });                  } });
# Line 102  Line 226 
226              assertTrue(task.isDone());              assertTrue(task.isDone());
227              assertTrue(task.isCancelled());              assertTrue(task.isCancelled());
228          } catch(InterruptedException e){          } catch(InterruptedException e){
229              fail("unexpected exception");              unexpectedException();
230          }          }
231      }      }
232    
233        /**
234         *
235         */
236      public void testGet1() {      public void testGet1() {
237          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
238                  public Object call(){                  public Object call(){
239                      try{                      try{
240                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
241                      } catch(InterruptedException e){                      } catch(InterruptedException e){
242                          fail("unexpected exception");                          threadUnexpectedException();
243                      }                      }
244                      return Boolean.TRUE;                      return Boolean.TRUE;
245                  }                  }
# Line 122  Line 249 
249                      try{                      try{
250                          ft.get();                          ft.get();
251                      } catch(Exception e){                      } catch(Exception e){
252                          fail("unexpected exception");                          threadUnexpectedException();
253                      }                      }
254                  }                  }
255              });              });
# Line 136  Line 263 
263              assertTrue(ft.isDone());              assertTrue(ft.isDone());
264              assertFalse(ft.isCancelled());              assertFalse(ft.isCancelled());
265          } catch(InterruptedException e){          } catch(InterruptedException e){
266              fail("unexpected exception");              unexpectedException();
267    
268          }          }
269      }      }
270    
271        /**
272         *
273         */
274      public void testTimedGet1() {      public void testTimedGet1() {
275          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
276                  public Object call(){                  public Object call(){
277                      try{                      try{
278                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
279                      } catch(InterruptedException e){                      } catch(InterruptedException e){
280                          fail("unexpected exception");                          threadUnexpectedException();
281                      }                      }
282                      return Boolean.TRUE;                      return Boolean.TRUE;
283                  }                  }
# Line 158  Line 288 
288                          ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);                          ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
289                      } catch(TimeoutException success) {                      } catch(TimeoutException success) {
290                      } catch(Exception e){                      } catch(Exception e){
291                          fail("unexpected exception");                          threadUnexpectedException();
292                      }                      }
293                  }                  }
294              });              });
# Line 171  Line 301 
301              assertTrue(ft.isDone());              assertTrue(ft.isDone());
302              assertFalse(ft.isCancelled());              assertFalse(ft.isCancelled());
303          } catch(InterruptedException e){          } catch(InterruptedException e){
304              fail("unexpected exception");              unexpectedException();
305    
306          }          }
307      }      }
308    
309    
310        /**
311         *
312         */
313      public void testGet_Cancellation(){      public void testGet_Cancellation(){
314          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
315                  public Object call(){                  public Object call(){
316                      try{                      try{
317                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
318                      } catch(InterruptedException e){                      } catch(InterruptedException e){
319                          fail("unexpected exception");                          threadUnexpectedException();
320                      }                      }
321                      return Boolean.TRUE;                      return Boolean.TRUE;
322                  }                  }
# Line 194  Line 327 
327                      public void run(){                      public void run(){
328                          try{                          try{
329                              ft.get();                              ft.get();
330                              fail("should throw");                              threadShouldThrow();
331                          } catch(CancellationException success){                          } catch(CancellationException success){
332                          }                          }
333                          catch(Exception e){                          catch(Exception e){
334                              fail("unexpected exception");                              threadUnexpectedException();
335                          }                          }
336                      }                      }
337                  });                  });
# Line 206  Line 339 
339              ft.cancel(true);              ft.cancel(true);
340              t.join();              t.join();
341          } catch(InterruptedException success){          } catch(InterruptedException success){
342              fail("unexpected exception");              unexpectedException();
343          }          }
344      }      }
345    
346        /**
347         *
348         */
349      public void testGet_Cancellation2(){      public void testGet_Cancellation2(){
350          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
351                  public Object call(){                  public Object call(){
352                      try{                      try{
353                          Thread.sleep(SHORT_DELAY_MS);                          Thread.sleep(SHORT_DELAY_MS);
354                      } catch(InterruptedException e) {                      } catch(InterruptedException e) {
355                          fail("unexpected exception");                          threadUnexpectedException();
356                      }                      }
357                      return Boolean.TRUE;                      return Boolean.TRUE;
358                  }                  }
359              });              });
360          try{          try{
361              Thread.sleep(100);              Thread.sleep(SHORT_DELAY_MS);
362              Thread t = new Thread(new Runnable(){              Thread t = new Thread(new Runnable(){
363                      public void run(){                      public void run(){
364                          try{                          try{
365                              ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
366                              fail("should throw");                              threadShouldThrow();
367                          } catch(CancellationException success) {}                          } catch(CancellationException success) {}
368                          catch(Exception e){                          catch(Exception e){
369                              fail("unexpected exception");                              threadUnexpectedException();
370                          }                          }
371                      }                      }
372                  });                  });
# Line 240  Line 376 
376              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
377              t.join();              t.join();
378          } catch(InterruptedException ie){          } catch(InterruptedException ie){
379              fail("unexpected exception");              unexpectedException();
380          }          }
381      }      }
382    
383        /**
384         *
385         */
386      public void testGet_ExecutionException(){      public void testGet_ExecutionException(){
387          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
388                  public Object call(){                  public Object call(){
# Line 254  Line 393 
393          try{          try{
394              ft.run();              ft.run();
395              ft.get();              ft.get();
396              fail("should throw");              shouldThrow();
397          } catch(ExecutionException success){          } catch(ExecutionException success){
398          }          }
399          catch(Exception e){          catch(Exception e){
400              fail("unexpected exception");              unexpectedException();
401          }          }
402      }      }
403    
404        /**
405         *
406         */
407      public void testTimedGet_ExecutionException2(){      public void testTimedGet_ExecutionException2(){
408          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new Callable(){
409                  public Object call(){                  public Object call(){
# Line 272  Line 414 
414          try{          try{
415              ft.run();              ft.run();
416              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
417              fail("should throw");              shouldThrow();
418          } catch(ExecutionException success) {          } catch(ExecutionException success) {
419          } catch(TimeoutException success) { } // unlikely but OK          } catch(TimeoutException success) { } // unlikely but OK
420          catch(Exception e){          catch(Exception e){
421              fail("unexpected exception");              unexpectedException();
422          }          }
423      }      }
424    
425    
426        /**
427         *
428         */
429      public void testGet_InterruptedException(){      public void testGet_InterruptedException(){
430          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new NoOpCallable());
                 public Object call(){  
                     return new Object();  
                 }  
             });  
431          Thread t = new Thread(new Runnable(){          Thread t = new Thread(new Runnable(){
432                  public void run(){                  public void run(){
433                      try{                      try{
434                          ft.get();                          ft.get();
435                          fail("should throw");                          threadShouldThrow();
436                      } catch(InterruptedException success){                      } catch(InterruptedException success){
437                      } catch(Exception e){                      } catch(Exception e){
438                          fail("unexpected exception");                          threadUnexpectedException();
439                      }                      }
440                  }                  }
441              });              });
# Line 304  Line 445 
445              t.interrupt();              t.interrupt();
446              t.join();              t.join();
447          } catch(Exception e){          } catch(Exception e){
448              fail("unexpected exception");              unexpectedException();
449          }          }
450      }      }
451    
452        /**
453         *
454         */
455      public void testTimedGet_InterruptedException2(){      public void testTimedGet_InterruptedException2(){
456          final FutureTask ft = new FutureTask(new Callable(){          final FutureTask ft = new FutureTask(new NoOpCallable());
                 public Object call(){  
                     return new Object();  
                 }  
             });  
457          Thread t = new Thread(new Runnable(){          Thread t = new Thread(new Runnable(){
458                  public void run(){                  public void run(){
459                      try{                      try{
460                          ft.get(100,TimeUnit.SECONDS);                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);
461                          fail("should throw");                          threadShouldThrow();
462                      } catch(InterruptedException success){}                      } catch(InterruptedException success){}
463                      catch(Exception e){                      catch(Exception e){
464                          fail("unexpected exception");                          threadUnexpectedException();
465                      }                      }
466                  }                  }
467              });              });
# Line 331  Line 471 
471              t.interrupt();              t.interrupt();
472              t.join();              t.join();
473          } catch(Exception e){          } catch(Exception e){
474              fail("unexpected exception");              unexpectedException();
475          }          }
476      }      }
477    
478        /**
479         *
480         */
481      public void testGet_TimeoutException(){      public void testGet_TimeoutException(){
         FutureTask ft = new FutureTask(new Callable(){  
                 public Object call(){  
                     return new Object();  
                 }  
             });  
482          try{          try{
483                FutureTask ft = new FutureTask(new NoOpCallable());
484              ft.get(1,TimeUnit.MILLISECONDS);              ft.get(1,TimeUnit.MILLISECONDS);
485              fail("should throw");              shouldThrow();
486          } catch(TimeoutException success){}          } catch(TimeoutException success){}
487          catch(Exception success){          catch(Exception success){
488              fail("unexpected exception");              unexpectedException();
489          }          }
   
   
490      }      }
491    
492  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8