[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.22, Sun Nov 28 20:20:00 2010 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.*;
10  import java.util.concurrent.*;  import java.util.concurrent.*;
11    import static java.util.concurrent.TimeUnit.MILLISECONDS;
12    import static java.util.concurrent.TimeUnit.SECONDS;
13  import java.util.*;  import java.util.*;
14    
15  public class FutureTaskTest extends JSR166TestCase {  public class FutureTaskTest extends JSR166TestCase {
# Line 18  Line 21 
21          return new TestSuite(FutureTaskTest.class);          return new TestSuite(FutureTaskTest.class);
22      }      }
23    
24        void checkNotDone(Future<?> f) {
25            assertFalse(f.isDone());
26            assertFalse(f.isCancelled());
27        }
28    
29        <T> void checkCompletedNormally(Future<T> f, T expected) {
30            assertTrue(f.isDone());
31            assertFalse(f.isCancelled());
32    
33            try {
34                assertSame(expected, f.get());
35            } catch (Throwable fail) { threadUnexpectedException(fail); }
36            try {
37                assertSame(expected, f.get(5L, SECONDS));
38            } catch (Throwable fail) { threadUnexpectedException(fail); }
39    
40            assertFalse(f.cancel(false));
41            assertFalse(f.cancel(true));
42        }
43    
44        void checkCancelled(Future<?> f) {
45            assertTrue(f.isDone());
46            assertTrue(f.isCancelled());
47    
48            try {
49                f.get();
50                shouldThrow();
51            } catch (CancellationException success) {
52            } catch (Throwable fail) { threadUnexpectedException(fail); }
53    
54            try {
55                f.get(5L, SECONDS);
56                shouldThrow();
57            } catch (CancellationException success) {
58            } catch (Throwable fail) { threadUnexpectedException(fail); }
59    
60            assertFalse(f.cancel(false));
61            assertFalse(f.cancel(true));
62        }
63    
64        void checkCompletedAbnormally(Future<?> f, Throwable t) {
65            assertTrue(f.isDone());
66            assertFalse(f.isCancelled());
67    
68            try {
69                f.get();
70                shouldThrow();
71            } catch (ExecutionException success) {
72                assertSame(t, success.getCause());
73            } catch (Throwable fail) { threadUnexpectedException(fail); }
74    
75            try {
76                f.get(5L, SECONDS);
77                shouldThrow();
78            } catch (ExecutionException success) {
79                assertSame(t, success.getCause());
80            } catch (Throwable fail) { threadUnexpectedException(fail); }
81    
82            assertFalse(f.cancel(false));
83            assertFalse(f.cancel(true));
84        }
85    
86      /**      /**
87       * Subclass to expose protected methods       * Subclass to expose protected methods
88       */       */
89      static class MyFutureTask extends FutureTask {      static class PublicFutureTask extends FutureTask {
90          public MyFutureTask(Callable r) { super(r); }          public PublicFutureTask(Callable r) { super(r); }
91          public boolean reset() { return super.reset(); }          public boolean runAndReset() { return super.runAndReset(); }
         public void setCancelled() { super.setCancelled(); }  
         public void setDone() { super.setDone(); }  
92          public void set(Object x) { super.set(x); }          public void set(Object x) { super.set(x); }
93          public void setException(Throwable t) { super.setException(t); }          public void setException(Throwable t) { super.setException(t); }
94      }      }
95    
96      /**      /**
97       *       * Creating a future with a null callable throws NPE
98       */       */
99      public void testConstructor() {      public void testConstructor() {
100          try {          try {
101              FutureTask task = new FutureTask(null);              FutureTask task = new FutureTask(null);
102              shouldThrow();              shouldThrow();
103          }          } catch (NullPointerException success) {}
         catch(NullPointerException success) {  
         }  
104      }      }
105    
106      /**      /**
107       *       * creating a future with null runnable fails
108       */       */
109      public void testConstructor2() {      public void testConstructor2() {
110          try {          try {
111              FutureTask task = new FutureTask(null, Boolean.TRUE);              FutureTask task = new FutureTask(null, Boolean.TRUE);
112              shouldThrow();              shouldThrow();
113          }          } catch (NullPointerException success) {}
         catch(NullPointerException success) {  
         }  
114      }      }
115    
116      /**      /**
117       *       * isDone is true when a task completes
118       */       */
119      public void testIsDone() {      public void testIsDone() {
120          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
121          task.run();          task.run();
122          assertTrue(task.isDone());          assertTrue(task.isDone());
123          assertFalse(task.isCancelled());          checkCompletedNormally(task, Boolean.TRUE);
124      }      }
125    
126      /**      /**
127       *       * runAndReset of a non-cancelled task succeeds
128       */       */
129      public void testReset() {      public void testRunAndReset() {
130          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
131          task.run();          assertTrue(task.runAndReset());
132          assertTrue(task.isDone());          checkNotDone(task);
         assertTrue(task.reset());  
133      }      }
134    
135      /**      /**
136       *       * runAndReset after cancellation fails
137       */       */
138      public void testResetAfterCancel() {      public void testResetAfterCancel() {
139          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
140          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
141          task.run();          assertFalse(task.runAndReset());
142          assertTrue(task.isDone());          checkCancelled(task);
         assertTrue(task.isCancelled());  
         assertFalse(task.reset());  
143      }      }
144    
     /**  
      *  
      */  
     public void testSetDone() {  
         MyFutureTask task = new MyFutureTask(new NoOpCallable());  
         task.setDone();  
         assertTrue(task.isDone());  
         assertFalse(task.isCancelled());  
     }  
   
     /**  
      *  
      */  
     public void testSetCancelled() {  
         MyFutureTask task = new MyFutureTask(new NoOpCallable());  
         assertTrue(task.cancel(false));  
         task.setCancelled();  
         assertTrue(task.isDone());  
         assertTrue(task.isCancelled());  
     }  
145    
146      /**      /**
147       *       * setting value causes get to return it
148       */       */
149      public void testSet() {      public void testSet() throws Exception {
150          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
151          task.set(one);          task.set(one);
152          try {          assertSame(task.get(), one);
153              assertEquals(task.get(), one);          checkCompletedNormally(task, one);
         }  
         catch(Exception e) {  
             unexpectedException();  
         }  
154      }      }
155    
156      /**      /**
157       *       * setException causes get to throw ExecutionException
158       */       */
159      public void testSetException() {      public void testSetException() throws Exception {
160          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
161          MyFutureTask task = new MyFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
162          task.setException(nse);          task.setException(nse);
163          try {          try {
164              Object x = task.get();              Object x = task.get();
165              shouldThrow();              shouldThrow();
166          }          } catch (ExecutionException success) {
167          catch(ExecutionException ee) {              assertSame(success.getCause(), nse);
168              Throwable cause = ee.getCause();              checkCompletedAbnormally(task, nse);
             assertEquals(cause, nse);  
         }  
         catch(Exception e) {  
             unexpectedException();  
169          }          }
170      }      }
171    
172      /**      /**
173       *       * Cancelling before running succeeds
174       */       */
175      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
176          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
177          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
178          task.run();          task.run();
179          assertTrue(task.isDone());          checkCancelled(task);
         assertTrue(task.isCancelled());  
180      }      }
181    
182      /**      /**
183       *       * Cancel(true) before run succeeds
184       */       */
185      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
186          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
187          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
188          task.run();          task.run();
189          assertTrue(task.isDone());          checkCancelled(task);
         assertTrue(task.isCancelled());  
190      }      }
191    
192      /**      /**
193       *       * cancel of a completed task fails
194       */       */
195      public void testCancelAfterRun() {      public void testCancelAfterRun() {
196          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
197          task.run();          task.run();
198          assertFalse(task.cancel(false));          assertFalse(task.cancel(false));
199          assertTrue(task.isDone());          checkCompletedNormally(task, Boolean.TRUE);
         assertFalse(task.isCancelled());  
200      }      }
201    
202      /**      /**
203       *       * cancel(true) interrupts a running task
204       */       */
205      public void testCancelInterrupt() {      public void testCancelInterrupt() throws InterruptedException {
206          FutureTask task = new FutureTask( new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
207                  public Object call() {          final FutureTask task =
208                      try {              new FutureTask(new CheckedCallable<Object>() {
209                          Thread.sleep(MEDIUM_DELAY_MS);                  public Object realCall() {
210                          threadShouldThrow();                      threadStarted.countDown();
211                      }                      long t0 = System.nanoTime();
212                      catch (InterruptedException success) {}                      for (;;) {
213                            if (Thread.interrupted())
214                      return Boolean.TRUE;                      return Boolean.TRUE;
215                            if (millisElapsedSince(t0) > MEDIUM_DELAY_MS)
216                                fail("interrupt not delivered");
217                            Thread.yield();
218                        }
219                  } });                  } });
         Thread t = new  Thread(task);  
         t.start();  
220    
221          try {          Thread t = newStartedThread(task);
222              Thread.sleep(SHORT_DELAY_MS);          threadStarted.await();
223              assertTrue(task.cancel(true));              assertTrue(task.cancel(true));
224              t.join();          checkCancelled(task);
225              assertTrue(task.isDone());          awaitTermination(t, MEDIUM_DELAY_MS);
226              assertTrue(task.isCancelled());          checkCancelled(task);
         } catch(InterruptedException e){  
             unexpectedException();  
227          }          }
     }  
   
228    
229      /**      /**
230       *       * cancel(false) does not interrupt a running task
231       */       */
232      public void testCancelNoInterrupt() {      public void testCancelNoInterrupt() throws InterruptedException {
233          FutureTask task = new FutureTask( new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
234                  public Object call() {          final CountDownLatch cancelled = new CountDownLatch(1);
235                      try {          final FutureTask<Boolean> task =
236                          Thread.sleep(MEDIUM_DELAY_MS);              new FutureTask<Boolean>(new CheckedCallable<Boolean>() {
237                      }                  public Boolean realCall() throws InterruptedException {
238                      catch (InterruptedException success) {                      threadStarted.countDown();
239                          threadFail("should not interrupt");                      cancelled.await(MEDIUM_DELAY_MS, MILLISECONDS);
240                      }                      assertFalse(Thread.interrupted());
241                      return Boolean.TRUE;                      return Boolean.TRUE;
242                  } });                  } });
         Thread t = new  Thread(task);  
         t.start();  
243    
244          try {          Thread t = newStartedThread(task);
245              Thread.sleep(SHORT_DELAY_MS);          threadStarted.await();
246              assertTrue(task.cancel(false));              assertTrue(task.cancel(false));
247              t.join();          checkCancelled(task);
248              assertTrue(task.isDone());          cancelled.countDown();
249              assertTrue(task.isCancelled());          awaitTermination(t, MEDIUM_DELAY_MS);
250          } catch(InterruptedException e){          checkCancelled(task);
             unexpectedException();  
         }  
251      }      }
252    
253      /**      /**
254       *       * set in one thread causes get in another thread to retrieve value
255       */       */
256      public void testGet1() {      public void testGet1() throws InterruptedException {
257          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask task =
258                  public Object call() {              new FutureTask(new CheckedCallable<Object>() {
259                      try {                  public Object realCall() throws InterruptedException {
                         Thread.sleep(MEDIUM_DELAY_MS);  
                     } catch(InterruptedException e){  
                         threadUnexpectedException();  
                     }  
260                      return Boolean.TRUE;                      return Boolean.TRUE;
261                  }                  }});
262          });          checkNotDone(task);
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         ft.get();  
                     } catch(Exception e){  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
             assertFalse(ft.isDone());  
             assertFalse(ft.isCancelled());  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             ft.run();  
             t.join();  
             assertTrue(ft.isDone());  
             assertFalse(ft.isCancelled());  
         } catch(InterruptedException e){  
             unexpectedException();  
263    
264          }          Thread t = newStartedThread(new CheckedRunnable() {
265                public void realRun() throws Exception {
266                    assertSame(Boolean.TRUE, task.get());
267                }});
268    
269            task.run();
270            checkCompletedNormally(task, Boolean.TRUE);
271            awaitTermination(t, MEDIUM_DELAY_MS);
272      }      }
273    
274      /**      /**
275       *       * set in one thread causes timed get in another thread to retrieve value
276       */       */
277      public void testTimedGet1() {      public void testTimedGet1() throws InterruptedException {
278          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask task =
279                  public Object call() {              new FutureTask(new CheckedCallable<Object>() {
280                      try {                  public Object realCall() throws InterruptedException {
                         Thread.sleep(MEDIUM_DELAY_MS);  
                     } catch(InterruptedException e){  
                         threadUnexpectedException();  
                     }  
281                      return Boolean.TRUE;                      return Boolean.TRUE;
282                  }                  }});
283              });          checkNotDone(task);
         Thread t = new Thread(new Runnable() {  
                 public void run() {  
                     try {  
                         ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);  
                     } catch(TimeoutException success) {  
                     } catch(Exception e){  
                         threadUnexpectedException();  
                     }  
                 }  
             });  
         try {  
             assertFalse(ft.isDone());  
             assertFalse(ft.isCancelled());  
             t.start();  
             ft.run();  
             t.join();  
             assertTrue(ft.isDone());  
             assertFalse(ft.isCancelled());  
         } catch(InterruptedException e){  
             unexpectedException();  
284    
285          }          Thread t = newStartedThread(new CheckedRunnable() {
286      }              public void realRun() throws Exception {
287                    assertSame(Boolean.TRUE, task.get(SMALL_DELAY_MS, MILLISECONDS));
288                }});
289    
290            task.run();
291            checkCompletedNormally(task, Boolean.TRUE);
292            awaitTermination(t, MEDIUM_DELAY_MS);
293        }
294    
295      /**      /**
296       *       * Cancelling a task causes timed get in another thread to throw
297         * CancellationException
298       */       */
299      public void testGet_Cancellation() {      public void testTimedGet_Cancellation() throws InterruptedException {
300          final FutureTask ft = new FutureTask(new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(2);
301                  public Object call() {          final FutureTask task =
302                      try {              new FutureTask(new CheckedInterruptedCallable<Object>() {
303                          Thread.sleep(MEDIUM_DELAY_MS);                  public Object realCall() throws InterruptedException {
304                      } catch(InterruptedException e){                      threadStarted.countDown();
305                          threadUnexpectedException();                      Thread.sleep(LONG_DELAY_MS);
                     }  
306                      return Boolean.TRUE;                      return Boolean.TRUE;
307                  }                  }});
308              });  
309          try {          Thread t1 = new ThreadShouldThrow(CancellationException.class) {
310              Thread.sleep(SHORT_DELAY_MS);              public void realRun() throws Exception {
311              Thread t = new Thread(new Runnable() {                  threadStarted.countDown();
312                      public void run() {                  task.get(MEDIUM_DELAY_MS, MILLISECONDS);
313                          try {              }};
314                              ft.get();          Thread t2 = new Thread(task);
315                              threadShouldThrow();          t1.start();
316                          } catch(CancellationException success){          t2.start();
317                          }          threadStarted.await();
318                          catch(Exception e){          task.cancel(true);
319                              threadUnexpectedException();          awaitTermination(t1, MEDIUM_DELAY_MS);
320                          }          awaitTermination(t2, MEDIUM_DELAY_MS);
321                      }          checkCancelled(task);
                 });  
             t.start();  
             ft.cancel(true);  
             t.join();  
         } catch(InterruptedException success){  
             unexpectedException();  
         }  
322      }      }
323    
324      /**      /**
325       *       * Cancelling a task causes get in another thread to throw
326       */       * CancellationException
327      public void testGet_Cancellation2() {       */
328          final FutureTask ft = new FutureTask(new Callable() {      public void testGet_Cancellation() throws InterruptedException {
329                  public Object call() {          final CountDownLatch threadStarted = new CountDownLatch(2);
330                      try {          final FutureTask task =
331                          Thread.sleep(SHORT_DELAY_MS);              new FutureTask(new CheckedInterruptedCallable<Object>() {
332                      } catch(InterruptedException e) {                  public Object realCall() throws InterruptedException {
333                          threadUnexpectedException();                      threadStarted.countDown();
334                      }                      Thread.sleep(LONG_DELAY_MS);
335                      return Boolean.TRUE;                      return Boolean.TRUE;
336                  }                  }});
337              });  
338          try {          Thread t1 = new ThreadShouldThrow(CancellationException.class) {
339              Thread.sleep(SHORT_DELAY_MS);              public void realRun() throws Exception {
340              Thread t = new Thread(new Runnable() {                  threadStarted.countDown();
341                      public void run() {                  task.get();
342                          try {              }};
343                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);          Thread t2 = new Thread(task);
344                              threadShouldThrow();          t1.start();
345                          } catch(CancellationException success) {}          t2.start();
346                          catch(Exception e){          threadStarted.await();
347                              threadUnexpectedException();          task.cancel(true);
348                          }          awaitTermination(t1, MEDIUM_DELAY_MS);
349                      }          awaitTermination(t2, MEDIUM_DELAY_MS);
350                  });          checkCancelled(task);
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             ft.cancel(true);  
             Thread.sleep(SHORT_DELAY_MS);  
             t.join();  
         } catch(InterruptedException ie){  
             unexpectedException();  
         }  
351      }      }
352    
353    
354      /**      /**
355       *       * A runtime exception in task causes get to throw ExecutionException
356       */       */
357      public void testGet_ExecutionException() {      public void testGet_ExecutionException() throws InterruptedException {
358          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask task = new FutureTask(new Callable() {
359                  public Object call() {                  public Object call() {
360                      int i = 5/0;                  return 5/0;
361                      return Boolean.TRUE;              }});
362                  }  
363              });          task.run();
364          try {          try {
365              ft.run();              task.get();
             ft.get();  
366              shouldThrow();              shouldThrow();
367          } catch(ExecutionException success){          } catch(ExecutionException success){
368          }              assertTrue(success.getCause() instanceof ArithmeticException);
369          catch(Exception e){              checkCompletedAbnormally(task, success.getCause());
             unexpectedException();  
370          }          }
371      }      }
372    
373      /**      /**
374       *       * A runtime exception in task causes timed get to throw ExecutionException
375       */       */
376      public void testTimedGet_ExecutionException2() {      public void testTimedGet_ExecutionException2() throws Exception {
377          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask task = new FutureTask(new Callable() {
378                  public Object call() {                  public Object call() {
379                      int i = 5/0;                  return 5/0;
380                      return Boolean.TRUE;              }});
381                  }  
382              });          task.run();
383          try {          try {
384              ft.run();              task.get(SHORT_DELAY_MS, MILLISECONDS);
             ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);  
385              shouldThrow();              shouldThrow();
386          } catch(ExecutionException success) {          } catch(ExecutionException success) {
387          } catch(TimeoutException success) { } // unlikely but OK              assertTrue(success.getCause() instanceof ArithmeticException);
388          catch(Exception e){              checkCompletedAbnormally(task, success.getCause());
             unexpectedException();  
389          }          }
390      }      }
391    
392    
393      /**      /**
394       *       * Interrupting a waiting get causes it to throw InterruptedException
395       */       */
396      public void testGet_InterruptedException() {      public void testGet_InterruptedException() throws InterruptedException {
397          final FutureTask ft = new FutureTask(new NoOpCallable());          final CountDownLatch threadStarted = new CountDownLatch(1);
398          Thread t = new Thread(new Runnable() {          final FutureTask task = new FutureTask(new NoOpCallable());
399                  public void run() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
400                      try {              public void realRun() throws Exception {
401                          ft.get();                  threadStarted.countDown();
402                          threadShouldThrow();                  task.get();
403                      } catch(InterruptedException success){              }});
404                      } catch(Exception e){  
405                          threadUnexpectedException();          threadStarted.await();
                     }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
406              t.interrupt();              t.interrupt();
407              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
408          } catch(Exception e){          checkNotDone(task);
             unexpectedException();  
         }  
409      }      }
410    
411      /**      /**
412       *       * Interrupting a waiting timed get causes it to throw InterruptedException
413       */       */
414      public void testTimedGet_InterruptedException2() {      public void testTimedGet_InterruptedException2() throws InterruptedException {
415          final FutureTask ft = new FutureTask(new NoOpCallable());          final CountDownLatch threadStarted = new CountDownLatch(1);
416          Thread t = new Thread(new Runnable() {          final FutureTask task = new FutureTask(new NoOpCallable());
417                  public void run() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
418                      try {              public void realRun() throws Exception {
419                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);                  threadStarted.countDown();
420                          threadShouldThrow();                  task.get(LONG_DELAY_MS, MILLISECONDS);
421                      } catch(InterruptedException success){}              }});
422                      catch(Exception e){  
423                          threadUnexpectedException();          threadStarted.await();
                     }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
424              t.interrupt();              t.interrupt();
425              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
426          } catch(Exception e){          checkNotDone(task);
             unexpectedException();  
         }  
427      }      }
428    
429      /**      /**
430       *       * A timed out timed get throws TimeoutException
431       */       */
432      public void testGet_TimeoutException() {      public void testGet_TimeoutException() throws Exception {
433          try {          try {
434              FutureTask ft = new FutureTask(new NoOpCallable());              FutureTask task = new FutureTask(new NoOpCallable());
435              ft.get(1,TimeUnit.MILLISECONDS);              task.get(1, MILLISECONDS);
436              shouldThrow();              shouldThrow();
437          } catch(TimeoutException success){}          } catch(TimeoutException success){}
         catch(Exception success){  
             unexpectedException();  
         }  
438      }      }
439    
440  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8