[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.24, Tue Mar 15 19:47:06 2011 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/publicdomain/zero/1.0/
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.*;
14    
15  public class FutureTaskTest extends TestCase {  public class FutureTaskTest extends JSR166TestCase {
16    
17      public static void main(String[] args) {      public static void main(String[] args) {
18          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
# Line 17  Line 21 
21          return new TestSuite(FutureTaskTest.class);          return new TestSuite(FutureTaskTest.class);
22      }      }
23    
24      private static long SHORT_DELAY_MS = 100;      void checkNotDone(Future<?> f) {
25      private static long MEDIUM_DELAY_MS = 1000;          assertFalse(f.isDone());
26      private static long LONG_DELAY_MS = 10000;          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
88         */
89        static class PublicFutureTask extends FutureTask {
90            public PublicFutureTask(Callable r) { super(r); }
91            public boolean runAndReset() { return super.runAndReset(); }
92            public void set(Object x) { super.set(x); }
93            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() {
100            try {
101                FutureTask task = new FutureTask(null);
102                shouldThrow();
103            } catch (NullPointerException success) {}
104        }
105    
106        /**
107         * creating a future with null runnable fails
108         */
109        public void testConstructor2() {
110            try {
111                FutureTask task = new FutureTask(null, Boolean.TRUE);
112                shouldThrow();
113            } 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 Callable() {          FutureTask task = new FutureTask(new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
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 testRunAndReset() {
130            PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
131            assertTrue(task.runAndReset());
132            checkNotDone(task);
133      }      }
134    
135        /**
136         * runAndReset after cancellation fails
137         */
138        public void testResetAfterCancel() {
139            PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
140            assertTrue(task.cancel(false));
141            assertFalse(task.runAndReset());
142            checkCancelled(task);
143        }
144    
145    
146        /**
147         * setting value causes get to return it
148         */
149        public void testSet() throws Exception {
150            PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
151            task.set(one);
152            assertSame(task.get(), one);
153            checkCompletedNormally(task, one);
154        }
155    
156        /**
157         * setException causes get to throw ExecutionException
158         */
159        public void testSetException() throws Exception {
160            Exception nse = new NoSuchElementException();
161            PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
162            task.setException(nse);
163            try {
164                Object x = task.get();
165                shouldThrow();
166            } catch (ExecutionException success) {
167                assertSame(success.getCause(), nse);
168                checkCompletedAbnormally(task, nse);
169            }
170        }
171    
172        /**
173         * Cancelling before running succeeds
174         */
175      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
176          FutureTask task = new FutureTask( new Callable() {          FutureTask task = new FutureTask(new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
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 Callable() {          FutureTask task = new FutureTask(new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
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 Callable() {          FutureTask task = new FutureTask(new NoOpCallable());
                 public Object call() { return Boolean.TRUE; } });  
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      public void testCancelInterrupt(){      /**
203          FutureTask task = new FutureTask( new Callable() {       * cancel(true) interrupts a running task
204                  public Object call() {       */
205                      try {      public void testCancelInterrupt() throws InterruptedException {
206                          Thread.sleep(SHORT_DELAY_MS* 2);          final CountDownLatch threadStarted = new CountDownLatch(1);
207                          fail("should throw");          final FutureTask task =
208                      }              new FutureTask(new CheckedCallable<Object>() {
209                      catch (InterruptedException success) {}                  public Object realCall() {
210                        threadStarted.countDown();
211                        long t0 = System.nanoTime();
212                        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){  
             fail("unexpected exception");  
         }  
227      }      }
228    
229        /**
230      public void testCancelNoInterrupt(){       * cancel(false) does not interrupt a running task
231          FutureTask task = new FutureTask( new Callable() {       */
232                  public Object call() {      public void testCancelNoInterrupt() throws InterruptedException {
233                      try {          final CountDownLatch threadStarted = new CountDownLatch(1);
234                          Thread.sleep(SHORT_DELAY_MS* 2);          final CountDownLatch cancelled = new CountDownLatch(1);
235                      }          final FutureTask<Boolean> task =
236                      catch (InterruptedException success) {              new FutureTask<Boolean>(new CheckedCallable<Boolean>() {
237                          fail("should not interrupt");                  public Boolean realCall() throws InterruptedException {
238                      }                      threadStarted.countDown();
239                        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);
             fail("unexpected exception");  
         }  
251      }      }
252    
253      public void testGet1() {      /**
254          final FutureTask ft = new FutureTask(new Callable(){       * run in one thread causes get in another thread to retrieve value
255                  public Object call(){       */
256                      try{      public void testGetRun() throws InterruptedException {
257                          Thread.sleep(MEDIUM_DELAY_MS);          final CountDownLatch threadStarted = new CountDownLatch(1);
258                      } catch(InterruptedException e){  
259                          fail("unexpected exception");          final FutureTask task =
260                      }              new FutureTask(new CheckedCallable<Object>() {
261                    public Object realCall() throws InterruptedException {
262                      return Boolean.TRUE;                      return Boolean.TRUE;
263                  }                  }});
         });  
         Thread t = new Thread(new Runnable(){  
                 public void run(){  
                     try{  
                         ft.get();  
                     } catch(Exception e){  
                         fail("unexpected exception");  
                     }  
                 }  
             });  
         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){  
             fail("unexpected exception");  
264    
265          }          Thread t = newStartedThread(new CheckedRunnable() {
266      }              public void realRun() throws Exception {
267                    threadStarted.countDown();
268                    assertSame(Boolean.TRUE, task.get());
269                }});
270    
271      public void testTimedGet1() {          threadStarted.await();
272          final FutureTask ft = new FutureTask(new Callable(){          checkNotDone(task);
273                  public Object call(){          assertTrue(t.isAlive());
274                      try{          task.run();
275                          Thread.sleep(MEDIUM_DELAY_MS);          checkCompletedNormally(task, Boolean.TRUE);
276                      } catch(InterruptedException e){          awaitTermination(t, MEDIUM_DELAY_MS);
                         fail("unexpected exception");  
277                      }                      }
278    
279        /**
280         * set in one thread causes get in another thread to retrieve value
281         */
282        public void testGetSet() throws InterruptedException {
283            final CountDownLatch threadStarted = new CountDownLatch(1);
284    
285            final PublicFutureTask task =
286                new PublicFutureTask(new CheckedCallable<Object>() {
287                    public Object realCall() throws InterruptedException {
288                      return Boolean.TRUE;                      return Boolean.TRUE;
289                  }                  }});
             });  
         Thread t = new Thread(new Runnable(){  
                 public void run(){  
                     try{  
                         ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);  
                     } catch(TimeoutException success) {  
                     } catch(Exception e){  
                         fail("unexpected exception");  
                     }  
                 }  
             });  
         try{  
             assertFalse(ft.isDone());  
             assertFalse(ft.isCancelled());  
             t.start();  
             ft.run();  
             t.join();  
             assertTrue(ft.isDone());  
             assertFalse(ft.isCancelled());  
         } catch(InterruptedException e){  
             fail("unexpected exception");  
290    
291          }          Thread t = newStartedThread(new CheckedRunnable() {
292                public void realRun() throws Exception {
293                    threadStarted.countDown();
294                    assertSame(Boolean.FALSE, task.get());
295                }});
296    
297            threadStarted.await();
298            checkNotDone(task);
299            assertTrue(t.isAlive());
300            task.set(Boolean.FALSE);
301            checkCompletedNormally(task, Boolean.FALSE);
302            awaitTermination(t, MEDIUM_DELAY_MS);
303      }      }
304    
305        /**
306         * run in one thread causes timed get in another thread to retrieve value
307         */
308        public void testTimedGetRun() throws InterruptedException {
309            final CountDownLatch threadStarted = new CountDownLatch(1);
310    
311      public void testGet_Cancellation(){          final FutureTask task =
312          final FutureTask ft = new FutureTask(new Callable(){              new FutureTask(new CheckedCallable<Object>() {
313                  public Object call(){                  public Object realCall() throws InterruptedException {
                     try{  
                         Thread.sleep(MEDIUM_DELAY_MS);  
                     } catch(InterruptedException e){  
                         fail("unexpected exception");  
                     }  
314                      return Boolean.TRUE;                      return Boolean.TRUE;
315                  }                  }});
             });  
         try {  
             Thread.sleep(SHORT_DELAY_MS);  
             Thread t = new Thread(new Runnable(){  
                     public void run(){  
                         try{  
                             ft.get();  
                             fail("should throw");  
                         } catch(CancellationException success){  
                         }  
                         catch(Exception e){  
                             fail("unexpected exception");  
                         }  
                     }  
                 });  
             t.start();  
             ft.cancel(true);  
             t.join();  
         } catch(InterruptedException success){  
             fail("unexpected exception");  
         }  
     }  
316    
317      public void testGet_Cancellation2(){          Thread t = newStartedThread(new CheckedRunnable() {
318          final FutureTask ft = new FutureTask(new Callable(){              public void realRun() throws Exception {
319                  public Object call(){                  threadStarted.countDown();
320                      try{                  assertSame(Boolean.TRUE,
321                          Thread.sleep(SHORT_DELAY_MS);                             task.get(MEDIUM_DELAY_MS, MILLISECONDS));
322                      } catch(InterruptedException e) {              }});
323                          fail("unexpected exception");  
324            threadStarted.await();
325            checkNotDone(task);
326            assertTrue(t.isAlive());
327            task.run();
328            checkCompletedNormally(task, Boolean.TRUE);
329            awaitTermination(t, MEDIUM_DELAY_MS);
330                      }                      }
331    
332        /**
333         * set in one thread causes timed get in another thread to retrieve value
334         */
335        public void testTimedGetSet() throws InterruptedException {
336            final CountDownLatch threadStarted = new CountDownLatch(1);
337    
338            final PublicFutureTask task =
339                new PublicFutureTask(new CheckedCallable<Object>() {
340                    public Object realCall() throws InterruptedException {
341                      return Boolean.TRUE;                      return Boolean.TRUE;
342                  }                  }});
343              });  
344          try{          Thread t = newStartedThread(new CheckedRunnable() {
345              Thread.sleep(100);              public void realRun() throws Exception {
346              Thread t = new Thread(new Runnable(){                  threadStarted.countDown();
347                      public void run(){                  assertSame(Boolean.FALSE,
348                          try{                             task.get(MEDIUM_DELAY_MS, MILLISECONDS));
349                              ft.get(3 * SHORT_DELAY_MS, TimeUnit.MILLISECONDS);              }});
350                              fail("should throw");  
351                          } catch(CancellationException success) {}          threadStarted.await();
352                          catch(Exception e){          checkNotDone(task);
353                              fail("unexpected exception");          assertTrue(t.isAlive());
354                          }          task.set(Boolean.FALSE);
355                      }          checkCompletedNormally(task, Boolean.FALSE);
356                  });          awaitTermination(t, MEDIUM_DELAY_MS);
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
             ft.cancel(true);  
             Thread.sleep(SHORT_DELAY_MS);  
             t.join();  
         } catch(InterruptedException ie){  
             fail("unexpected exception");  
         }  
357      }      }
358    
359      public void testGet_ExecutionException(){      /**
360          final FutureTask ft = new FutureTask(new Callable(){       * Cancelling a task causes timed get in another thread to throw
361                  public Object call(){       * CancellationException
362                      int i = 5/0;       */
363        public void testTimedGet_Cancellation() throws InterruptedException {
364            final CountDownLatch threadStarted = new CountDownLatch(2);
365            final FutureTask task =
366                new FutureTask(new CheckedInterruptedCallable<Object>() {
367                    public Object realCall() throws InterruptedException {
368                        threadStarted.countDown();
369                        Thread.sleep(LONG_DELAY_MS);
370                      return Boolean.TRUE;                      return Boolean.TRUE;
371                    }});
372    
373            Thread t1 = new ThreadShouldThrow(CancellationException.class) {
374                public void realRun() throws Exception {
375                    threadStarted.countDown();
376                    task.get(MEDIUM_DELAY_MS, MILLISECONDS);
377                }};
378            Thread t2 = new Thread(task);
379            t1.start();
380            t2.start();
381            threadStarted.await();
382            task.cancel(true);
383            awaitTermination(t1, MEDIUM_DELAY_MS);
384            awaitTermination(t2, MEDIUM_DELAY_MS);
385            checkCancelled(task);
386        }
387    
388        /**
389         * Cancelling a task causes get in another thread to throw
390         * CancellationException
391         */
392        public void testGet_Cancellation() throws InterruptedException {
393            final CountDownLatch threadStarted = new CountDownLatch(2);
394            final FutureTask task =
395                new FutureTask(new CheckedInterruptedCallable<Object>() {
396                    public Object realCall() throws InterruptedException {
397                        threadStarted.countDown();
398                        Thread.sleep(LONG_DELAY_MS);
399                        return Boolean.TRUE;
400                    }});
401    
402            Thread t1 = new ThreadShouldThrow(CancellationException.class) {
403                public void realRun() throws Exception {
404                    threadStarted.countDown();
405                    task.get();
406                }};
407            Thread t2 = new Thread(task);
408            t1.start();
409            t2.start();
410            threadStarted.await();
411            task.cancel(true);
412            awaitTermination(t1, MEDIUM_DELAY_MS);
413            awaitTermination(t2, MEDIUM_DELAY_MS);
414            checkCancelled(task);
415                  }                  }
416              });  
417    
418        /**
419         * A runtime exception in task causes get to throw ExecutionException
420         */
421        public void testGet_ExecutionException() throws InterruptedException {
422            final FutureTask task = new FutureTask(new Callable() {
423                public Object call() {
424                    return 5/0;
425                }});
426    
427            task.run();
428          try{          try{
429              ft.run();              task.get();
430              ft.get();              shouldThrow();
             fail("should throw");  
431          } catch(ExecutionException success){          } catch(ExecutionException success){
432          }              assertTrue(success.getCause() instanceof ArithmeticException);
433          catch(Exception e){              checkCompletedAbnormally(task, success.getCause());
             fail("unexpected exception");  
434          }          }
435      }      }
436    
437      public void testTimedGet_ExecutionException2(){      /**
438          final FutureTask ft = new FutureTask(new Callable(){       * A runtime exception in task causes timed get to throw ExecutionException
439         */
440        public void testTimedGet_ExecutionException2() throws Exception {
441            final FutureTask task = new FutureTask(new Callable() {
442                  public Object call(){                  public Object call(){
443                      int i = 5/0;                  return 5/0;
444                      return Boolean.TRUE;              }});
445                  }  
446              });          task.run();
447          try{          try{
448              ft.run();              task.get(SHORT_DELAY_MS, MILLISECONDS);
449              ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);              shouldThrow();
             fail("should throw");  
450          } catch(ExecutionException success) {          } catch(ExecutionException success) {
451          } catch(TimeoutException success) { } // unlikely but OK              assertTrue(success.getCause() instanceof ArithmeticException);
452          catch(Exception e){              checkCompletedAbnormally(task, success.getCause());
             fail("unexpected exception");  
453          }          }
454      }      }
455    
456    
457      public void testGet_InterruptedException(){      /**
458          final FutureTask ft = new FutureTask(new Callable(){       * Interrupting a waiting get causes it to throw InterruptedException
459                  public Object call(){       */
460                      return new Object();      public void testGet_InterruptedException() throws InterruptedException {
461                  }          final CountDownLatch threadStarted = new CountDownLatch(1);
462              });          final FutureTask task = new FutureTask(new NoOpCallable());
463          Thread t = new Thread(new Runnable(){          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
464                  public void run(){              public void realRun() throws Exception {
465                      try{                  threadStarted.countDown();
466                          ft.get();                  task.get();
467                          fail("should throw");              }});
468                      } catch(InterruptedException success){  
469                      } catch(Exception e){          threadStarted.await();
                         fail("unexpected exception");  
                     }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
470              t.interrupt();              t.interrupt();
471              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
472          } catch(Exception e){          checkNotDone(task);
             fail("unexpected exception");  
         }  
473      }      }
474    
475      public void testTimedGet_InterruptedException2(){      /**
476          final FutureTask ft = new FutureTask(new Callable(){       * Interrupting a waiting timed get causes it to throw InterruptedException
477                  public Object call(){       */
478                      return new Object();      public void testTimedGet_InterruptedException2() throws InterruptedException {
479                  }          final CountDownLatch threadStarted = new CountDownLatch(1);
480              });          final FutureTask task = new FutureTask(new NoOpCallable());
481          Thread t = new Thread(new Runnable(){          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
482                  public void run(){              public void realRun() throws Exception {
483                      try{                  threadStarted.countDown();
484                          ft.get(100,TimeUnit.SECONDS);                  task.get(LONG_DELAY_MS, MILLISECONDS);
485                          fail("should throw");              }});
486                      } catch(InterruptedException success){}  
487                      catch(Exception e){          threadStarted.await();
                         fail("unexpected exception");  
                     }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
488              t.interrupt();              t.interrupt();
489              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
490          } catch(Exception e){          checkNotDone(task);
             fail("unexpected exception");  
         }  
491      }      }
492    
493      public void testGet_TimeoutException(){      /**
494          FutureTask ft = new FutureTask(new Callable(){       * A timed out timed get throws TimeoutException
495                  public Object call(){       */
496                      return new Object();      public void testGet_TimeoutException() throws Exception {
                 }  
             });  
497          try{          try{
498              ft.get(1,TimeUnit.MILLISECONDS);              FutureTask task = new FutureTask(new NoOpCallable());
499              fail("should throw");              task.get(1, MILLISECONDS);
500                shouldThrow();
501          } catch(TimeoutException success){}          } catch(TimeoutException success){}
         catch(Exception success){  
             fail("unexpected exception");  
         }  
   
   
502      }      }
503    
504  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8