[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.8, Mon Dec 22 00:48:55 2003 UTC revision 1.26, Tue May 31 16:16:23 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.*;  import java.util.*;
20    
21  public class FutureTaskTest extends JSR166TestCase {  public class FutureTaskTest extends JSR166TestCase {
# Line 18  Line 27 
27          return new TestSuite(FutureTaskTest.class);          return new TestSuite(FutureTaskTest.class);
28      }      }
29    
30        void checkNotDone(Future<?> f) {
31            assertFalse(f.isDone());
32            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       * Subclass to expose protected methods
94       */       */
95      static class PublicFutureTask extends FutureTask {      static class PublicFutureTask extends FutureTask {
96          public PublicFutureTask(Callable r) { super(r); }          public PublicFutureTask(Callable r) { super(r); }
97          public boolean reset() { return super.reset(); }          public boolean runAndReset() { return super.runAndReset(); }
         public void setCancelled() { super.setCancelled(); }  
98          public void set(Object x) { super.set(x); }          public void set(Object x) { super.set(x); }
99          public void setException(Throwable t) { super.setException(t); }          public void setException(Throwable t) { super.setException(t); }
100      }      }
# Line 36  Line 106 
106          try {          try {
107              FutureTask task = new FutureTask(null);              FutureTask task = new FutureTask(null);
108              shouldThrow();              shouldThrow();
109          }          } catch (NullPointerException success) {}
         catch(NullPointerException success) {  
         }  
110      }      }
111    
112      /**      /**
# Line 48  Line 116 
116          try {          try {
117              FutureTask task = new FutureTask(null, Boolean.TRUE);              FutureTask task = new FutureTask(null, Boolean.TRUE);
118              shouldThrow();              shouldThrow();
119          }          } catch (NullPointerException success) {}
         catch(NullPointerException success) {  
         }  
120      }      }
121    
122      /**      /**
# Line 60  Line 126 
126          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
127          task.run();          task.run();
128          assertTrue(task.isDone());          assertTrue(task.isDone());
129          assertFalse(task.isCancelled());          checkCompletedNormally(task, Boolean.TRUE);
130      }      }
131    
132      /**      /**
133       * reset of a done task succeeds and changes status to not done       * runAndReset of a non-cancelled task succeeds
134       */       */
135      public void testReset() {      public void testRunAndReset() {
136          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
137          task.run();          assertTrue(task.runAndReset());
138          assertTrue(task.isDone());          checkNotDone(task);
         assertTrue(task.reset());  
         assertFalse(task.isDone());  
139      }      }
140    
141      /**      /**
142       * Resetting after cancellation fails       * runAndReset after cancellation fails
143       */       */
144      public void testResetAfterCancel() {      public void testResetAfterCancel() {
145          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
146          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
147          task.run();          assertFalse(task.runAndReset());
148          assertTrue(task.isDone());          checkCancelled(task);
         assertTrue(task.isCancelled());  
         assertFalse(task.reset());  
149      }      }
150    
151    
152      /**      /**
153       * setCancelled of a new task causes isCancelled to be true       * setting value causes get to return it
      */  
     public void testSetCancelled() {  
         PublicFutureTask task = new PublicFutureTask(new NoOpCallable());  
         assertTrue(task.cancel(false));  
         task.setCancelled();  
         assertTrue(task.isDone());  
         assertTrue(task.isCancelled());  
     }  
   
     /**  
      * setting value gauses get to return it  
154       */       */
155      public void testSet() {      public void testSet() throws Exception {
156          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
157          task.set(one);          task.set(one);
158          try {          assertSame(task.get(), one);
159              assertEquals(task.get(), one);          checkCompletedNormally(task, one);
         }  
         catch(Exception e) {  
             unexpectedException();  
         }  
160      }      }
161    
162      /**      /**
163       * setException causes get to throw ExecutionException       * setException causes get to throw ExecutionException
164       */       */
165      public void testSetException() {      public void testSetException() throws Exception {
166          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
167          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
168          task.setException(nse);          task.setException(nse);
169          try {          try {
170              Object x = task.get();              Object x = task.get();
171              shouldThrow();              shouldThrow();
172          }          } catch (ExecutionException success) {
173          catch(ExecutionException ee) {              assertSame(success.getCause(), nse);
174              Throwable cause = ee.getCause();              checkCompletedAbnormally(task, nse);
             assertEquals(cause, nse);  
         }  
         catch(Exception e) {  
             unexpectedException();  
175          }          }
176      }      }
177    
# Line 139  Line 182 
182          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
183          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
184          task.run();          task.run();
185          assertTrue(task.isDone());          checkCancelled(task);
         assertTrue(task.isCancelled());  
186      }      }
187    
188      /**      /**
# Line 150  Line 192 
192          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
193          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
194          task.run();          task.run();
195          assertTrue(task.isDone());          checkCancelled(task);
         assertTrue(task.isCancelled());  
196      }      }
197    
198      /**      /**
# Line 161  Line 202 
202          FutureTask task = new FutureTask( new NoOpCallable());          FutureTask task = new FutureTask( new NoOpCallable());
203          task.run();          task.run();
204          assertFalse(task.cancel(false));          assertFalse(task.cancel(false));
205          assertTrue(task.isDone());          checkCompletedNormally(task, Boolean.TRUE);
         assertFalse(task.isCancelled());  
206      }      }
207    
208      /**      /**
209       * cancel(true) interrupts a running task       * cancel(true) interrupts a running task
210       */       */
211      public void testCancelInterrupt() {      public void testCancelInterrupt() throws InterruptedException {
212          FutureTask task = new FutureTask( new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
213                  public Object call() {          final FutureTask task =
214                      try {              new FutureTask(new CheckedCallable<Object>() {
215                          Thread.sleep(MEDIUM_DELAY_MS);                  public Object realCall() {
216                          threadShouldThrow();                      threadStarted.countDown();
217                      }                      long t0 = System.nanoTime();
218                      catch (InterruptedException success) {}                      for (;;) {
219                            if (Thread.interrupted())
220                      return Boolean.TRUE;                      return Boolean.TRUE;
221                            if (millisElapsedSince(t0) > MEDIUM_DELAY_MS)
222                                fail("interrupt not delivered");
223                            Thread.yield();
224                        }
225                  } });                  } });
         Thread t = new  Thread(task);  
         t.start();  
226    
227          try {          Thread t = newStartedThread(task);
228              Thread.sleep(SHORT_DELAY_MS);          threadStarted.await();
229              assertTrue(task.cancel(true));              assertTrue(task.cancel(true));
230              t.join();          checkCancelled(task);
231              assertTrue(task.isDone());          awaitTermination(t, MEDIUM_DELAY_MS);
232              assertTrue(task.isCancelled());          checkCancelled(task);
         } catch(InterruptedException e){  
             unexpectedException();  
233          }          }
     }  
   
234    
235      /**      /**
236       * cancel(false) does not interrupt a running task       * cancel(false) does not interrupt a running task
237       */       */
238      public void testCancelNoInterrupt() {      public void testCancelNoInterrupt() throws InterruptedException {
239          FutureTask task = new FutureTask( new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
240                  public Object call() {          final CountDownLatch cancelled = new CountDownLatch(1);
241                      try {          final FutureTask<Boolean> task =
242                          Thread.sleep(MEDIUM_DELAY_MS);              new FutureTask<Boolean>(new CheckedCallable<Boolean>() {
243                      }                  public Boolean realCall() throws InterruptedException {
244                      catch (InterruptedException success) {                      threadStarted.countDown();
245                          threadFail("should not interrupt");                      cancelled.await(MEDIUM_DELAY_MS, MILLISECONDS);
246                      }                      assertFalse(Thread.interrupted());
247                      return Boolean.TRUE;                      return Boolean.TRUE;
248                  } });                  } });
         Thread t = new  Thread(task);  
         t.start();  
249    
250          try {          Thread t = newStartedThread(task);
251              Thread.sleep(SHORT_DELAY_MS);          threadStarted.await();
252              assertTrue(task.cancel(false));              assertTrue(task.cancel(false));
253              t.join();          checkCancelled(task);
254              assertTrue(task.isDone());          cancelled.countDown();
255              assertTrue(task.isCancelled());          awaitTermination(t, MEDIUM_DELAY_MS);
256          } catch(InterruptedException e){          checkCancelled(task);
             unexpectedException();  
257          }          }
258    
259        /**
260         * run in one thread causes get in another thread to retrieve value
261         */
262        public void testGetRun() throws InterruptedException {
263            final CountDownLatch threadStarted = new CountDownLatch(1);
264    
265            final FutureTask task =
266                new FutureTask(new CheckedCallable<Object>() {
267                    public Object realCall() throws InterruptedException {
268                        return Boolean.TRUE;
269                    }});
270    
271            Thread t = newStartedThread(new CheckedRunnable() {
272                public void realRun() throws Exception {
273                    threadStarted.countDown();
274                    assertSame(Boolean.TRUE, task.get());
275                }});
276    
277            threadStarted.await();
278            checkNotDone(task);
279            assertTrue(t.isAlive());
280            task.run();
281            checkCompletedNormally(task, Boolean.TRUE);
282            awaitTermination(t, MEDIUM_DELAY_MS);
283      }      }
284    
285      /**      /**
286       * set in one thread causes get in another thread to retrieve value       * set in one thread causes get in another thread to retrieve value
287       */       */
288      public void testGet1() {      public void testGetSet() throws InterruptedException {
289          final FutureTask ft = new FutureTask(new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
290                  public Object call() {  
291                      try {          final PublicFutureTask task =
292                          Thread.sleep(MEDIUM_DELAY_MS);              new PublicFutureTask(new CheckedCallable<Object>() {
293                      } catch(InterruptedException e){                  public Object realCall() throws InterruptedException {
                         threadUnexpectedException();  
                     }  
294                      return Boolean.TRUE;                      return Boolean.TRUE;
295                  }                  }});
         });  
         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();  
296    
297          }          Thread t = newStartedThread(new CheckedRunnable() {
298                public void realRun() throws Exception {
299                    threadStarted.countDown();
300                    assertSame(Boolean.FALSE, task.get());
301                }});
302    
303            threadStarted.await();
304            checkNotDone(task);
305            assertTrue(t.isAlive());
306            task.set(Boolean.FALSE);
307            checkCompletedNormally(task, Boolean.FALSE);
308            awaitTermination(t, MEDIUM_DELAY_MS);
309      }      }
310    
311      /**      /**
312       * set in one thread causes timed get in another thread to retrieve value       * run in one thread causes timed get in another thread to retrieve value
313       */       */
314      public void testTimedGet1() {      public void testTimedGetRun() throws InterruptedException {
315          final FutureTask ft = new FutureTask(new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
316                  public Object call() {  
317                      try {          final FutureTask task =
318                          Thread.sleep(MEDIUM_DELAY_MS);              new FutureTask(new CheckedCallable<Object>() {
319                      } catch(InterruptedException e){                  public Object realCall() throws InterruptedException {
                         threadUnexpectedException();  
                     }  
320                      return Boolean.TRUE;                      return Boolean.TRUE;
321                  }                  }});
             });  
         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();  
322    
323          }          Thread t = newStartedThread(new CheckedRunnable() {
324                public void realRun() throws Exception {
325                    threadStarted.countDown();
326                    assertSame(Boolean.TRUE,
327                               task.get(MEDIUM_DELAY_MS, MILLISECONDS));
328                }});
329    
330            threadStarted.await();
331            checkNotDone(task);
332            assertTrue(t.isAlive());
333            task.run();
334            checkCompletedNormally(task, Boolean.TRUE);
335            awaitTermination(t, MEDIUM_DELAY_MS);
336      }      }
337    
338      /**      /**
339       *  Cancelling a task causes timed get in another thread to throw CancellationException       * set in one thread causes timed get in another thread to retrieve value
340       */       */
341      public void testTimedGet_Cancellation() {      public void testTimedGetSet() throws InterruptedException {
342          final FutureTask ft = new FutureTask(new Callable() {          final CountDownLatch threadStarted = new CountDownLatch(1);
343                  public Object call() {  
344                      try {          final PublicFutureTask task =
345                          Thread.sleep(SMALL_DELAY_MS);              new PublicFutureTask(new CheckedCallable<Object>() {
346                          threadShouldThrow();                  public Object realCall() throws InterruptedException {
                     } catch(InterruptedException e) {  
                     }  
347                      return Boolean.TRUE;                      return Boolean.TRUE;
348                    }});
349    
350            Thread t = newStartedThread(new CheckedRunnable() {
351                public void realRun() throws Exception {
352                    threadStarted.countDown();
353                    assertSame(Boolean.FALSE,
354                               task.get(MEDIUM_DELAY_MS, MILLISECONDS));
355                }});
356    
357            threadStarted.await();
358            checkNotDone(task);
359            assertTrue(t.isAlive());
360            task.set(Boolean.FALSE);
361            checkCompletedNormally(task, Boolean.FALSE);
362            awaitTermination(t, MEDIUM_DELAY_MS);
363                  }                  }
364              });  
365          try {      /**
366              Thread t1 = new Thread(new Runnable() {       * Cancelling a task causes timed get in another thread to throw
367                      public void run() {       * CancellationException
368                          try {       */
369                              ft.get(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS);      public void testTimedGet_Cancellation() throws InterruptedException {
370                              threadShouldThrow();          final CountDownLatch threadStarted = new CountDownLatch(2);
371                          } catch(CancellationException success) {}          final FutureTask task =
372                          catch(Exception e){              new FutureTask(new CheckedInterruptedCallable<Object>() {
373                              threadUnexpectedException();                  public Object realCall() throws InterruptedException {
374                          }                      threadStarted.countDown();
375                      }                      delay(LONG_DELAY_MS);
376                  });                      return Boolean.TRUE;
377              Thread t2 = new Thread(ft);                  }});
378    
379            Thread t1 = new ThreadShouldThrow(CancellationException.class) {
380                public void realRun() throws Exception {
381                    threadStarted.countDown();
382                    task.get(MEDIUM_DELAY_MS, MILLISECONDS);
383                }};
384            Thread t2 = new Thread(task);
385              t1.start();              t1.start();
386              t2.start();              t2.start();
387              Thread.sleep(SHORT_DELAY_MS);          threadStarted.await();
388              ft.cancel(true);          task.cancel(true);
389              t1.join();          awaitTermination(t1, MEDIUM_DELAY_MS);
390              t2.join();          awaitTermination(t2, MEDIUM_DELAY_MS);
391          } catch(InterruptedException ie){          checkCancelled(task);
             unexpectedException();  
         }  
392      }      }
393    
394      /**      /**
395       * Cancelling a task causes get in another thread to throw CancellationException       * Cancelling a task causes get in another thread to throw
396       */       * CancellationException
397      public void testGet_Cancellation() {       */
398          final FutureTask ft = new FutureTask(new Callable() {      public void testGet_Cancellation() throws InterruptedException {
399                  public Object call() {          final CountDownLatch threadStarted = new CountDownLatch(2);
400                      try {          final FutureTask task =
401                          Thread.sleep(MEDIUM_DELAY_MS);              new FutureTask(new CheckedInterruptedCallable<Object>() {
402                          threadShouldThrow();                  public Object realCall() throws InterruptedException {
403                      } catch(InterruptedException e){                      threadStarted.countDown();
404                      }                      delay(LONG_DELAY_MS);
405                      return Boolean.TRUE;                      return Boolean.TRUE;
406                  }                  }});
407              });  
408          try {          Thread t1 = new ThreadShouldThrow(CancellationException.class) {
409              Thread t1 = new Thread(new Runnable() {              public void realRun() throws Exception {
410                      public void run() {                  threadStarted.countDown();
411                          try {                  task.get();
412                              ft.get();              }};
413                              threadShouldThrow();          Thread t2 = new Thread(task);
                         } catch(CancellationException success){  
                         }  
                         catch(Exception e){  
                             threadUnexpectedException();  
                         }  
                     }  
                 });  
             Thread t2 = new Thread(ft);  
414              t1.start();              t1.start();
415              t2.start();              t2.start();
416              Thread.sleep(SHORT_DELAY_MS);          threadStarted.await();
417              ft.cancel(true);          task.cancel(true);
418              t1.join();          awaitTermination(t1, MEDIUM_DELAY_MS);
419              t2.join();          awaitTermination(t2, MEDIUM_DELAY_MS);
420          } catch(InterruptedException success){          checkCancelled(task);
             unexpectedException();  
         }  
421      }      }
422    
423    
424      /**      /**
425       * A runtime exception in task causes get to throw ExecutionException       * A runtime exception in task causes get to throw ExecutionException
426       */       */
427      public void testGet_ExecutionException() {      public void testGet_ExecutionException() throws InterruptedException {
428          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask task = new FutureTask(new Callable() {
429                  public Object call() {                  public Object call() {
430                      int i = 5/0;                  return 5/0;
431                      return Boolean.TRUE;              }});
432                  }  
433              });          task.run();
434          try {          try {
435              ft.run();              task.get();
             ft.get();  
436              shouldThrow();              shouldThrow();
437          } catch(ExecutionException success){          } catch(ExecutionException success){
438          }              assertTrue(success.getCause() instanceof ArithmeticException);
439          catch(Exception e){              checkCompletedAbnormally(task, success.getCause());
             unexpectedException();  
440          }          }
441      }      }
442    
443      /**      /**
444       *  A runtime exception in task causes timed get to throw ExecutionException       *  A runtime exception in task causes timed get to throw ExecutionException
445       */       */
446      public void testTimedGet_ExecutionException2() {      public void testTimedGet_ExecutionException2() throws Exception {
447          final FutureTask ft = new FutureTask(new Callable() {          final FutureTask task = new FutureTask(new Callable() {
448                  public Object call() {                  public Object call() {
449                      int i = 5/0;                  return 5/0;
450                      return Boolean.TRUE;              }});
451                  }  
452              });          task.run();
453          try {          try {
454              ft.run();              task.get(SHORT_DELAY_MS, MILLISECONDS);
             ft.get(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);  
455              shouldThrow();              shouldThrow();
456          } catch(ExecutionException success) {          } catch(ExecutionException success) {
457          } catch(TimeoutException success) { } // unlikely but OK              assertTrue(success.getCause() instanceof ArithmeticException);
458          catch(Exception e){              checkCompletedAbnormally(task, success.getCause());
             unexpectedException();  
459          }          }
460      }      }
461    
# Line 421  Line 463 
463      /**      /**
464       * Interrupting a waiting get causes it to throw InterruptedException       * Interrupting a waiting get causes it to throw InterruptedException
465       */       */
466      public void testGet_InterruptedException() {      public void testGet_InterruptedException() throws InterruptedException {
467          final FutureTask ft = new FutureTask(new NoOpCallable());          final CountDownLatch threadStarted = new CountDownLatch(1);
468          Thread t = new Thread(new Runnable() {          final FutureTask task = new FutureTask(new NoOpCallable());
469                  public void run() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
470                      try {              public void realRun() throws Exception {
471                          ft.get();                  threadStarted.countDown();
472                          threadShouldThrow();                  task.get();
473                      } catch(InterruptedException success){              }});
474                      } catch(Exception e){  
475                          threadUnexpectedException();          threadStarted.await();
                     }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
476              t.interrupt();              t.interrupt();
477              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
478          } catch(Exception e){          checkNotDone(task);
             unexpectedException();  
         }  
479      }      }
480    
481      /**      /**
482       *  Interrupting a waiting timed get causes it to throw InterruptedException       *  Interrupting a waiting timed get causes it to throw InterruptedException
483       */       */
484      public void testTimedGet_InterruptedException2() {      public void testTimedGet_InterruptedException2() throws InterruptedException {
485          final FutureTask ft = new FutureTask(new NoOpCallable());          final CountDownLatch threadStarted = new CountDownLatch(1);
486          Thread t = new Thread(new Runnable() {          final FutureTask task = new FutureTask(new NoOpCallable());
487                  public void run() {          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
488                      try {              public void realRun() throws Exception {
489                          ft.get(LONG_DELAY_MS,TimeUnit.MILLISECONDS);                  threadStarted.countDown();
490                          threadShouldThrow();                  task.get(LONG_DELAY_MS, MILLISECONDS);
491                      } catch(InterruptedException success){}              }});
492                      catch(Exception e){  
493                          threadUnexpectedException();          threadStarted.await();
                     }  
                 }  
             });  
         try {  
             t.start();  
             Thread.sleep(SHORT_DELAY_MS);  
494              t.interrupt();              t.interrupt();
495              t.join();          awaitTermination(t, MEDIUM_DELAY_MS);
496          } catch(Exception e){          checkNotDone(task);
             unexpectedException();  
         }  
497      }      }
498    
499      /**      /**
500       * A timed out timed get throws TimeoutException       * A timed out timed get throws TimeoutException
501       */       */
502      public void testGet_TimeoutException() {      public void testGet_TimeoutException() throws Exception {
503          try {          try {
504              FutureTask ft = new FutureTask(new NoOpCallable());              FutureTask task = new FutureTask(new NoOpCallable());
505              ft.get(1,TimeUnit.MILLISECONDS);              task.get(1, MILLISECONDS);
506              shouldThrow();              shouldThrow();
507          } catch(TimeoutException success){}          } catch(TimeoutException success){}
         catch(Exception success){  
             unexpectedException();  
         }  
508      }      }
509    
510  }  }

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8