[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.8, Mon Dec 22 00:48:55 2003 UTC
# Line 21  Line 21 
21      /**      /**
22       * Subclass to expose protected methods       * Subclass to expose protected methods
23       */       */
24      static class MyFutureTask extends FutureTask {      static class PublicFutureTask extends FutureTask {
25          public MyFutureTask(Callable r) { super(r); }          public PublicFutureTask(Callable r) { super(r); }
26          public boolean reset() { return super.reset(); }          public boolean reset() { return super.reset(); }
27          public void setCancelled() { super.setCancelled(); }          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       *       * reset of a done task succeeds and changes status to not done
68       */       */
69      public void testReset() {      public void testReset() {
70          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
71          task.run();          task.run();
72          assertTrue(task.isDone());          assertTrue(task.isDone());
73          assertTrue(task.reset());          assertTrue(task.reset());
74            assertFalse(task.isDone());
75      }      }
76    
77      /**      /**
78       *       * Resetting after cancellation fails
79       */       */
80      public void testResetAfterCancel() {      public void testResetAfterCancel() {
81          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
82          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
83          task.run();          task.run();
84          assertTrue(task.isDone());          assertTrue(task.isDone());
# Line 86  Line 86 
86          assertFalse(task.reset());          assertFalse(task.reset());
87      }      }
88    
     /**  
      *  
      */  
     public void testSetDone() {  
         MyFutureTask task = new MyFutureTask(new NoOpCallable());  
         task.setDone();  
         assertTrue(task.isDone());  
         assertFalse(task.isCancelled());  
     }  
89    
90      /**      /**
91       *       * setCancelled of a new task causes isCancelled to be true
92       */       */
93      public void testSetCancelled() {      public void testSetCancelled() {
94          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
95          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
96          task.setCancelled();          task.setCancelled();
97          assertTrue(task.isDone());          assertTrue(task.isDone());
# Line 108  Line 99 
99      }      }
100    
101      /**      /**
102       *       * setting value gauses get to return it
103       */       */
104      public void testSet() {      public void testSet() {
105          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
106          task.set(one);          task.set(one);
107          try {          try {
108              assertEquals(task.get(), one);              assertEquals(task.get(), one);
# Line 122  Line 113 
113      }      }
114    
115      /**      /**
116       *       * setException causes get to throw ExecutionException
117       */       */
118      public void testSetException() {      public void testSetException() {
119          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
120          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
121          task.setException(nse);          task.setException(nse);
122          try {          try {
123              Object x = task.get();              Object x = task.get();
# Line 142  Line 133 
133      }      }
134    
135      /**      /**
136       *       *  Cancelling before running succeeds
137       */       */
138      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
139          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 153  Line 144 
144      }      }
145    
146      /**      /**
147       *       * Cancel(true) before run succeeds
148       */       */
149      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
150          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 164  Line 155 
155      }      }
156    
157      /**      /**
158       *       * cancel of a completed task fails
159       */       */
160      public void testCancelAfterRun() {      public void testCancelAfterRun() {
161          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 175  Line 166 
166      }      }
167    
168      /**      /**
169       *       * cancel(true) interrupts a running task
170       */       */
171      public void testCancelInterrupt() {      public void testCancelInterrupt() {
172          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
# Line 203  Line 194 
194    
195    
196      /**      /**
197       *       * cancel(false) does not interrupt a running task
198       */       */
199      public void testCancelNoInterrupt() {      public void testCancelNoInterrupt() {
200          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
# Line 231  Line 222 
222      }      }
223    
224      /**      /**
225       *       * set in one thread causes get in another thread to retrieve value
226       */       */
227      public void testGet1() {      public void testGet1() {
228          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 269  Line 260 
260      }      }
261    
262      /**      /**
263       *       * set in one thread causes timed get in another thread to retrieve value
264       */       */
265      public void testTimedGet1() {      public void testTimedGet1() {
266          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 306  Line 297 
297          }          }
298      }      }
299    
   
300      /**      /**
301       *       *  Cancelling a task causes timed get in another thread to throw CancellationException
302       */       */
303      public void testGet_Cancellation() {      public void testTimedGet_Cancellation() {
304          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
305                  public Object call() {                  public Object call() {
306                      try {                      try {
307                          Thread.sleep(MEDIUM_DELAY_MS);                          Thread.sleep(SMALL_DELAY_MS);
308                            threadShouldThrow();
309                      } catch(InterruptedException e){                      } catch(InterruptedException e){
                         threadUnexpectedException();  
310                      }                      }
311                      return Boolean.TRUE;                      return Boolean.TRUE;
312                  }                  }
313              });              });
314          try {          try {
315              Thread.sleep(SHORT_DELAY_MS);              Thread t1 = new Thread(new Runnable() {
             Thread t = new Thread(new Runnable() {  
316                      public void run() {                      public void run() {
317                          try {                          try {
318                              ft.get();                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
319                              threadShouldThrow();                              threadShouldThrow();
320                          } catch(CancellationException success){                          } catch(CancellationException success) {}
                         }  
321                          catch(Exception e){                          catch(Exception e){
322                              threadUnexpectedException();                              threadUnexpectedException();
323                          }                          }
324                      }                      }
325                  });                  });
326              t.start();              Thread t2 = new Thread(ft);
327                t1.start();
328                t2.start();
329                Thread.sleep(SHORT_DELAY_MS);
330              ft.cancel(true);              ft.cancel(true);
331              t.join();              t1.join();
332          } catch(InterruptedException success){              t2.join();
333            } catch(InterruptedException ie){
334              unexpectedException();              unexpectedException();
335          }          }
336      }      }
337    
338      /**      /**
339       *       * Cancelling a task causes get in another thread to throw CancellationException
340       */       */
341      public void testGet_Cancellation2() {      public void testGet_Cancellation() {
342          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
343                  public Object call() {                  public Object call() {
344                      try {                      try {
345                          Thread.sleep(SHORT_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
346                            threadShouldThrow();
347                      } catch(InterruptedException e) {                      } catch(InterruptedException e) {
                         threadUnexpectedException();  
348                      }                      }
349                      return Boolean.TRUE;                      return Boolean.TRUE;
350                  }                  }
351              });              });
352          try {          try {
353              Thread.sleep(SHORT_DELAY_MS);              Thread t1 = new Thread(new Runnable() {
             Thread t = new Thread(new Runnable() {  
354                      public void run() {                      public void run() {
355                          try {                          try {
356                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);                              ft.get();
357                              threadShouldThrow();                              threadShouldThrow();
358                          } catch(CancellationException success) {}                          } catch(CancellationException success){
359                            }
360                          catch(Exception e){                          catch(Exception e){
361                              threadUnexpectedException();                              threadUnexpectedException();
362                          }                          }
363                      }                      }
364                  });                  });
365              t.start();              Thread t2 = new Thread(ft);
366                t1.start();
367                t2.start();
368              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
369              ft.cancel(true);              ft.cancel(true);
370              Thread.sleep(SHORT_DELAY_MS);              t1.join();
371              t.join();              t2.join();
372          } catch(InterruptedException ie){          } catch(InterruptedException success){
373              unexpectedException();              unexpectedException();
374          }          }
375      }      }
376    
377    
378      /**      /**
379       *       * A runtime exception in task causes get to throw ExecutionException
380       */       */
381      public void testGet_ExecutionException() {      public void testGet_ExecutionException() {
382          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 402  Line 397 
397      }      }
398    
399      /**      /**
400       *       *  A runtime exception in task causes timed get to throw ExecutionException
401       */       */
402      public void testTimedGet_ExecutionException2() {      public void testTimedGet_ExecutionException2() {
403          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 424  Line 419 
419    
420    
421      /**      /**
422       *       * Interrupting a waiting get causes it to throw InterruptedException
423       */       */
424      public void testGet_InterruptedException() {      public void testGet_InterruptedException() {
425          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
# Line 450  Line 445 
445      }      }
446    
447      /**      /**
448       *       *  Interrupting a waiting timed get causes it to throw InterruptedException
449       */       */
450      public void testTimedGet_InterruptedException2() {      public void testTimedGet_InterruptedException2() {
451          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
# Line 476  Line 471 
471      }      }
472    
473      /**      /**
474       *       * A timed out timed get throws TimeoutException
475       */       */
476      public void testGet_TimeoutException() {      public void testGet_TimeoutException() {
477          try {          try {

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8