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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8