[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.5, Sat Sep 20 18:20:07 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 {
# Line 43  Line 42 
42      }      }
43    
44      /**      /**
45       *       * creating a future with null runnable fails
46       */       */
47      public void testConstructor2() {      public void testConstructor2() {
48          try {          try {
# Line 55  Line 54 
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());
# Line 65  Line 64 
64      }      }
65    
66      /**      /**
67       *       * runAndReset of a non-cancelled task succeeds
68       */       */
69      public void testReset() {      public void testRunAndReset() {
70          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
71          task.run();          assertTrue(task.runAndReset());
72          assertTrue(task.isDone());          assertFalse(task.isDone());
         assertTrue(task.reset());  
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);
# Line 122  Line 100 
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();
# Line 142  Line 120 
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());
# Line 153  Line 131 
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());
# Line 164  Line 142 
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());
# Line 175  Line 153 
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() {
# Line 203  Line 181 
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() {
# Line 231  Line 209 
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() {
# Line 269  Line 247 
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() {
# Line 306  Line 284 
284          }          }
285      }      }
286    
   
287      /**      /**
288       *       *  Cancelling a task causes timed get in another thread to throw CancellationException
289       */       */
290      public void testGet_Cancellation() {      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){
                         threadUnexpectedException();  
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                              threadShouldThrow();                              threadShouldThrow();
307                          } catch(CancellationException success){                          } catch(CancellationException success) {}
                         }  
308                          catch(Exception e){                          catch(Exception e){
309                              threadUnexpectedException();                              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            } catch(InterruptedException ie){
321              unexpectedException();              unexpectedException();
322          }          }
323      }      }
324    
325      /**      /**
326       *       * Cancelling a task causes get in another thread to throw CancellationException
327       */       */
328      public void testGet_Cancellation2() {      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) {
                         threadUnexpectedException();  
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                              threadShouldThrow();                              threadShouldThrow();
345                          } catch(CancellationException success) {}                          } catch(CancellationException success){
346                            }
347                          catch(Exception e){                          catch(Exception e){
348                              threadUnexpectedException();                              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              unexpectedException();              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() {
# Line 402  Line 384 
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() {
# Line 424  Line 406 
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());
# Line 450  Line 432 
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());
# Line 476  Line 458 
458      }      }
459    
460      /**      /**
461       *       * A timed out timed get throws TimeoutException
462       */       */
463      public void testGet_TimeoutException() {      public void testGet_TimeoutException() {
464          try {          try {

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8