[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.6, Thu Sep 25 11:02:41 2003 UTC
# Line 31  Line 31 
31      }      }
32    
33      /**      /**
34       *       * Creating a future with a null callable throws NPE
35       */       */
36      public void testConstructor() {      public void testConstructor() {
37          try {          try {
# Line 43  Line 43 
43      }      }
44    
45      /**      /**
46       *       * creating a future with null runnable fails
47       */       */
48      public void testConstructor2() {      public void testConstructor2() {
49          try {          try {
# Line 55  Line 55 
55      }      }
56    
57      /**      /**
58       *       * isDone is true when a task completes
59       */       */
60      public void testIsDone() {      public void testIsDone() {
61          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 65  Line 65 
65      }      }
66    
67      /**      /**
68       *       * reset of a done task succeeds and changes status to not done
69       */       */
70      public void testReset() {      public void testReset() {
71          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
72          task.run();          task.run();
73          assertTrue(task.isDone());          assertTrue(task.isDone());
74          assertTrue(task.reset());          assertTrue(task.reset());
75            assertFalse(task.isDone());
76      }      }
77    
78      /**      /**
79       *       * Resetting after cancellation fails
80       */       */
81      public void testResetAfterCancel() {      public void testResetAfterCancel() {
82          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
# Line 87  Line 88 
88      }      }
89    
90      /**      /**
91       *       * setDone of new task causes isDone to be true
92       */       */
93      public void testSetDone() {      public void testSetDone() {
94          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
# Line 97  Line 98 
98      }      }
99    
100      /**      /**
101       *       * setCancelled of a new task causes isCancelled to be true
102       */       */
103      public void testSetCancelled() {      public void testSetCancelled() {
104          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
# Line 108  Line 109 
109      }      }
110    
111      /**      /**
112       *       * setting value gauses get to return it
113       */       */
114      public void testSet() {      public void testSet() {
115          MyFutureTask task = new MyFutureTask(new NoOpCallable());          MyFutureTask task = new MyFutureTask(new NoOpCallable());
# Line 122  Line 123 
123      }      }
124    
125      /**      /**
126       *       * setException causes get to throw ExecutionException
127       */       */
128      public void testSetException() {      public void testSetException() {
129          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
# Line 142  Line 143 
143      }      }
144    
145      /**      /**
146       *       *  Cancelling before running succeeds
147       */       */
148      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
149          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 153  Line 154 
154      }      }
155    
156      /**      /**
157       *       * Cancel(true) before run succeeds
158       */       */
159      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
160          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 164  Line 165 
165      }      }
166    
167      /**      /**
168       *       * cancel of a completed task fails
169       */       */
170      public void testCancelAfterRun() {      public void testCancelAfterRun() {
171          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
# Line 175  Line 176 
176      }      }
177    
178      /**      /**
179       *       * cancel(true) interrupts a running task
180       */       */
181      public void testCancelInterrupt() {      public void testCancelInterrupt() {
182          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
# Line 203  Line 204 
204    
205    
206      /**      /**
207       *       * cancel(false) does not interrupt a running task
208       */       */
209      public void testCancelNoInterrupt() {      public void testCancelNoInterrupt() {
210          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask( new Callable() {
# Line 231  Line 232 
232      }      }
233    
234      /**      /**
235       *       * set in one thread causes get in another thread to retrieve value
236       */       */
237      public void testGet1() {      public void testGet1() {
238          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 269  Line 270 
270      }      }
271    
272      /**      /**
273       *       * set in one thread causes timed get in another thread to retrieve value
274       */       */
275      public void testTimedGet1() {      public void testTimedGet1() {
276          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 306  Line 307 
307          }          }
308      }      }
309    
   
310      /**      /**
311       *       *  Cancelling a task causes timed get in another thread to throw CancellationException
312       */       */
313      public void testGet_Cancellation() {      public void testTimedGet_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(SMALL_DELAY_MS);
318                            threadShouldThrow();
319                      } catch(InterruptedException e){                      } catch(InterruptedException e){
                         threadUnexpectedException();  
320                      }                      }
321                      return Boolean.TRUE;                      return Boolean.TRUE;
322                  }                  }
323              });              });
324          try {          try {
325              Thread.sleep(SHORT_DELAY_MS);              Thread t1 = new Thread(new Runnable() {
             Thread t = new Thread(new Runnable() {  
326                      public void run() {                      public void run() {
327                          try {                          try {
328                              ft.get();                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);
329                              threadShouldThrow();                              threadShouldThrow();
330                          } catch(CancellationException success){                          } catch(CancellationException success) {}
                         }  
331                          catch(Exception e){                          catch(Exception e){
332                              threadUnexpectedException();                              threadUnexpectedException();
333                          }                          }
334                      }                      }
335                  });                  });
336              t.start();              Thread t2 = new Thread(ft);
337                t1.start();
338                t2.start();
339                Thread.sleep(SHORT_DELAY_MS);
340              ft.cancel(true);              ft.cancel(true);
341              t.join();              t1.join();
342          } catch(InterruptedException success){              t2.join();
343            } catch(InterruptedException ie){
344              unexpectedException();              unexpectedException();
345          }          }
346      }      }
347    
348      /**      /**
349       *       * Cancelling a task causes get in another thread to throw CancellationException
350       */       */
351      public void testGet_Cancellation2() {      public void testGet_Cancellation() {
352          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
353                  public Object call() {                  public Object call() {
354                      try {                      try {
355                          Thread.sleep(SHORT_DELAY_MS);                          Thread.sleep(MEDIUM_DELAY_MS);
356                            threadShouldThrow();
357                      } catch(InterruptedException e) {                      } catch(InterruptedException e) {
                         threadUnexpectedException();  
358                      }                      }
359                      return Boolean.TRUE;                      return Boolean.TRUE;
360                  }                  }
361              });              });
362          try {          try {
363              Thread.sleep(SHORT_DELAY_MS);              Thread t1 = new Thread(new Runnable() {
             Thread t = new Thread(new Runnable() {  
364                      public void run() {                      public void run() {
365                          try {                          try {
366                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);                              ft.get();
367                              threadShouldThrow();                              threadShouldThrow();
368                          } catch(CancellationException success) {}                          } catch(CancellationException success){
369                            }
370                          catch(Exception e){                          catch(Exception e){
371                              threadUnexpectedException();                              threadUnexpectedException();
372                          }                          }
373                      }                      }
374                  });                  });
375              t.start();              Thread t2 = new Thread(ft);
376                t1.start();
377                t2.start();
378              Thread.sleep(SHORT_DELAY_MS);              Thread.sleep(SHORT_DELAY_MS);
379              ft.cancel(true);              ft.cancel(true);
380              Thread.sleep(SHORT_DELAY_MS);              t1.join();
381              t.join();              t2.join();
382          } catch(InterruptedException ie){          } catch(InterruptedException success){
383              unexpectedException();              unexpectedException();
384          }          }
385      }      }
386    
387    
388      /**      /**
389       *       * A runtime exception in task causes get to throw ExecutionException
390       */       */
391      public void testGet_ExecutionException() {      public void testGet_ExecutionException() {
392          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 402  Line 407 
407      }      }
408    
409      /**      /**
410       *       *  A runtime exception in task causes timed get to throw ExecutionException
411       */       */
412      public void testTimedGet_ExecutionException2() {      public void testTimedGet_ExecutionException2() {
413          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask ft = new FutureTask(new Callable() {
# Line 424  Line 429 
429    
430    
431      /**      /**
432       *       * Interrupting a waiting get causes it to throw InterruptedException
433       */       */
434      public void testGet_InterruptedException() {      public void testGet_InterruptedException() {
435          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
# Line 450  Line 455 
455      }      }
456    
457      /**      /**
458       *       *  Interrupting a waiting timed get causes it to throw InterruptedException
459       */       */
460      public void testTimedGet_InterruptedException2() {      public void testTimedGet_InterruptedException2() {
461          final FutureTask ft = new FutureTask(new NoOpCallable());          final FutureTask ft = new FutureTask(new NoOpCallable());
# Line 476  Line 481 
481      }      }
482    
483      /**      /**
484       *       * A timed out timed get throws TimeoutException
485       */       */
486      public void testGet_TimeoutException() {      public void testGet_TimeoutException() {
487          try {          try {

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8