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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8