[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.27, Sat Jun 18 14:16:42 2011 UTC revision 1.37, Sun Apr 21 06:54:11 2013 UTC
# Line 14  Line 14 
14  import java.util.concurrent.Future;  import java.util.concurrent.Future;
15  import java.util.concurrent.FutureTask;  import java.util.concurrent.FutureTask;
16  import java.util.concurrent.TimeoutException;  import java.util.concurrent.TimeoutException;
17    import java.util.concurrent.atomic.AtomicInteger;
18  import static java.util.concurrent.TimeUnit.MILLISECONDS;  import static java.util.concurrent.TimeUnit.MILLISECONDS;
19  import static java.util.concurrent.TimeUnit.SECONDS;  import static java.util.concurrent.TimeUnit.SECONDS;
20  import java.util.*;  import java.util.*;
# Line 27  Line 28 
28          return new TestSuite(FutureTaskTest.class);          return new TestSuite(FutureTaskTest.class);
29      }      }
30    
31        void checkIsDone(Future<?> f) {
32            assertTrue(f.isDone());
33            assertFalse(f.cancel(false));
34            assertFalse(f.cancel(true));
35            if (f instanceof PublicFutureTask) {
36                PublicFutureTask pf = (PublicFutureTask) f;
37                assertEquals(1, pf.doneCount());
38                assertFalse(pf.runAndReset());
39                assertEquals(1, pf.doneCount());
40                Object r = null; Object exInfo = null;
41                try {
42                    r = f.get();
43                } catch (CancellationException t) {
44                    exInfo = CancellationException.class;
45                } catch (ExecutionException t) {
46                    exInfo = t.getCause();
47                } catch (Throwable t) {
48                    threadUnexpectedException(t);
49                }
50    
51                // Check that run and runAndReset have no effect.
52                int savedRunCount = pf.runCount();
53                pf.run();
54                pf.runAndReset();
55                assertEquals(savedRunCount, pf.runCount());
56                try {
57                    assertSame(r, f.get());
58                } catch (CancellationException t) {
59                    assertSame(exInfo, CancellationException.class);
60                } catch (ExecutionException t) {
61                    assertSame(exInfo, t.getCause());
62                } catch (Throwable t) {
63                    threadUnexpectedException(t);
64                }
65                assertTrue(f.isDone());
66            }
67        }
68    
69      void checkNotDone(Future<?> f) {      void checkNotDone(Future<?> f) {
70          assertFalse(f.isDone());          assertFalse(f.isDone());
71          assertFalse(f.isCancelled());          assertFalse(f.isCancelled());
72            if (f instanceof PublicFutureTask) {
73                PublicFutureTask pf = (PublicFutureTask) f;
74                assertEquals(0, pf.doneCount());
75                assertEquals(0, pf.setCount());
76                assertEquals(0, pf.setExceptionCount());
77            }
78        }
79    
80        void checkIsRunning(Future<?> f) {
81            checkNotDone(f);
82            if (f instanceof FutureTask) {
83                FutureTask ft = (FutureTask<?>) f;
84                // Check that run methods do nothing
85                ft.run();
86                if (f instanceof PublicFutureTask) {
87                    PublicFutureTask pf = (PublicFutureTask) f;
88                    int savedRunCount = pf.runCount();
89                    pf.run();
90                    assertFalse(pf.runAndReset());
91                    assertEquals(savedRunCount, pf.runCount());
92                }
93                checkNotDone(f);
94            }
95      }      }
96    
97      <T> void checkCompletedNormally(Future<T> f, T expected) {      <T> void checkCompletedNormally(Future<T> f, T expected) {
98          assertTrue(f.isDone());          checkIsDone(f);
99          assertFalse(f.isCancelled());          assertFalse(f.isCancelled());
100    
101          try {          try {
# Line 42  Line 104 
104          try {          try {
105              assertSame(expected, f.get(5L, SECONDS));              assertSame(expected, f.get(5L, SECONDS));
106          } catch (Throwable fail) { threadUnexpectedException(fail); }          } catch (Throwable fail) { threadUnexpectedException(fail); }
   
         assertFalse(f.cancel(false));  
         assertFalse(f.cancel(true));  
107      }      }
108    
109      void checkCancelled(Future<?> f) {      void checkCancelled(Future<?> f) {
110          assertTrue(f.isDone());          checkIsDone(f);
111          assertTrue(f.isCancelled());          assertTrue(f.isCancelled());
112    
113          try {          try {
# Line 62  Line 121 
121              shouldThrow();              shouldThrow();
122          } catch (CancellationException success) {          } catch (CancellationException success) {
123          } catch (Throwable fail) { threadUnexpectedException(fail); }          } catch (Throwable fail) { threadUnexpectedException(fail); }
124        }
125    
126          assertFalse(f.cancel(false));      void tryToConfuseDoneTask(PublicFutureTask pf) {
127          assertFalse(f.cancel(true));          pf.set(new Object());
128            pf.setException(new Error());
129            for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
130                pf.cancel(true);
131            }
132      }      }
133    
134      void checkCompletedAbnormally(Future<?> f, Throwable t) {      void checkCompletedAbnormally(Future<?> f, Throwable t) {
135          assertTrue(f.isDone());          checkIsDone(f);
136          assertFalse(f.isCancelled());          assertFalse(f.isCancelled());
137    
138          try {          try {
# Line 84  Line 148 
148          } catch (ExecutionException success) {          } catch (ExecutionException success) {
149              assertSame(t, success.getCause());              assertSame(t, success.getCause());
150          } catch (Throwable fail) { threadUnexpectedException(fail); }          } catch (Throwable fail) { threadUnexpectedException(fail); }
   
         assertFalse(f.cancel(false));  
         assertFalse(f.cancel(true));  
151      }      }
152    
153      /**      /**
154       * Subclass to expose protected methods       * Subclass to expose protected methods
155       */       */
156      static class PublicFutureTask extends FutureTask {      static class PublicFutureTask extends FutureTask {
157          public PublicFutureTask(Callable r) { super(r); }          private final AtomicInteger runCount;
158          public boolean runAndReset() { return super.runAndReset(); }          private final AtomicInteger doneCount = new AtomicInteger(0);
159          public void set(Object x) { super.set(x); }          private final AtomicInteger runAndResetCount = new AtomicInteger(0);
160          public void setException(Throwable t) { super.setException(t); }          private final AtomicInteger setCount = new AtomicInteger(0);
161            private final AtomicInteger setExceptionCount = new AtomicInteger(0);
162            public int runCount() { return runCount.get(); }
163            public int doneCount() { return doneCount.get(); }
164            public int runAndResetCount() { return runAndResetCount.get(); }
165            public int setCount() { return setCount.get(); }
166            public int setExceptionCount() { return setExceptionCount.get(); }
167    
168            PublicFutureTask(Runnable runnable) {
169                this(runnable, seven);
170            }
171            PublicFutureTask(Runnable runnable, Object result) {
172                this(runnable, result, new AtomicInteger(0));
173            }
174            private PublicFutureTask(final Runnable runnable, Object result,
175                                     final AtomicInteger runCount) {
176                super(new Runnable() {
177                    public void run() {
178                        runCount.getAndIncrement();
179                        runnable.run();
180                    }}, result);
181                this.runCount = runCount;
182            }
183            PublicFutureTask(Callable callable) {
184                this(callable, new AtomicInteger(0));
185            }
186            private PublicFutureTask(final Callable callable,
187                                     final AtomicInteger runCount) {
188                super(new Callable() {
189                    public Object call() throws Exception {
190                        runCount.getAndIncrement();
191                        return callable.call();
192                    }});
193                this.runCount = runCount;
194            }
195            @Override public void done() {
196                assertTrue(isDone());
197                doneCount.incrementAndGet();
198                super.done();
199            }
200            @Override public boolean runAndReset() {
201                runAndResetCount.incrementAndGet();
202                return super.runAndReset();
203            }
204            @Override public void set(Object x) {
205                setCount.incrementAndGet();
206                super.set(x);
207            }
208            @Override public void setException(Throwable t) {
209                setExceptionCount.incrementAndGet();
210                super.setException(t);
211            }
212        }
213    
214        class Counter extends CheckedRunnable {
215            final AtomicInteger count = new AtomicInteger(0);
216            public int get() { return count.get(); }
217            public void realRun() {
218                count.getAndIncrement();
219            }
220      }      }
221    
222      /**      /**
223       * Creating a future with a null callable throws NPE       * creating a future with a null callable throws NullPointerException
224       */       */
225      public void testConstructor() {      public void testConstructor() {
226          try {          try {
227              FutureTask task = new FutureTask(null);              new FutureTask(null);
228              shouldThrow();              shouldThrow();
229          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
230      }      }
231    
232      /**      /**
233       * creating a future with null runnable fails       * creating a future with null runnable throws NullPointerException
234       */       */
235      public void testConstructor2() {      public void testConstructor2() {
236          try {          try {
237              FutureTask task = new FutureTask(null, Boolean.TRUE);              new FutureTask(null, Boolean.TRUE);
238              shouldThrow();              shouldThrow();
239          } catch (NullPointerException success) {}          } catch (NullPointerException success) {}
240      }      }
# Line 123  Line 243 
243       * isDone is true when a task completes       * isDone is true when a task completes
244       */       */
245      public void testIsDone() {      public void testIsDone() {
246          FutureTask task = new FutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
247            assertFalse(task.isDone());
248          task.run();          task.run();
249          assertTrue(task.isDone());          assertTrue(task.isDone());
250          checkCompletedNormally(task, Boolean.TRUE);          checkCompletedNormally(task, Boolean.TRUE);
251            assertEquals(1, task.runCount());
252      }      }
253    
254      /**      /**
# Line 134  Line 256 
256       */       */
257      public void testRunAndReset() {      public void testRunAndReset() {
258          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
259            for (int i = 0; i < 3; i++) {
260          assertTrue(task.runAndReset());          assertTrue(task.runAndReset());
261          checkNotDone(task);          checkNotDone(task);
262                assertEquals(i+1, task.runCount());
263                assertEquals(i+1, task.runAndResetCount());
264                assertEquals(0, task.setCount());
265                assertEquals(0, task.setExceptionCount());
266            }
267      }      }
268    
269      /**      /**
270       * runAndReset after cancellation fails       * runAndReset after cancellation fails
271       */       */
272      public void testResetAfterCancel() {      public void testRunAndResetAfterCancel() {
273            for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
274          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
275          assertTrue(task.cancel(false));              assertTrue(task.cancel(mayInterruptIfRunning));
276                for (int i = 0; i < 3; i++) {
277          assertFalse(task.runAndReset());          assertFalse(task.runAndReset());
278                    assertEquals(0, task.runCount());
279                    assertEquals(i+1, task.runAndResetCount());
280                    assertEquals(0, task.setCount());
281                    assertEquals(0, task.setExceptionCount());
282                }
283                tryToConfuseDoneTask(task);
284          checkCancelled(task);          checkCancelled(task);
285      }      }
286        }
287    
288      /**      /**
289       * setting value causes get to return it       * setting value causes get to return it
# Line 154  Line 291 
291      public void testSet() throws Exception {      public void testSet() throws Exception {
292          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
293          task.set(one);          task.set(one);
294          assertSame(task.get(), one);          for (int i = 0; i < 3; i++) {
295                assertSame(one, task.get());
296                assertSame(one, task.get(LONG_DELAY_MS, MILLISECONDS));
297                assertEquals(1, task.setCount());
298            }
299            tryToConfuseDoneTask(task);
300          checkCompletedNormally(task, one);          checkCompletedNormally(task, one);
301            assertEquals(0, task.runCount());
302      }      }
303    
304      /**      /**
305       * setException causes get to throw ExecutionException       * setException causes get to throw ExecutionException
306       */       */
307      public void testSetException() throws Exception {      public void testSetException_get() throws Exception {
308          Exception nse = new NoSuchElementException();          Exception nse = new NoSuchElementException();
309          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
310          task.setException(nse);          task.setException(nse);
311    
312            try {
313                task.get();
314                shouldThrow();
315            } catch (ExecutionException success) {
316                assertSame(nse, success.getCause());
317                checkCompletedAbnormally(task, nse);
318            }
319    
320          try {          try {
321              Object x = task.get();              task.get(LONG_DELAY_MS, MILLISECONDS);
322              shouldThrow();              shouldThrow();
323          } catch (ExecutionException success) {          } catch (ExecutionException success) {
324              assertSame(success.getCause(), nse);              assertSame(nse, success.getCause());
325              checkCompletedAbnormally(task, nse);              checkCompletedAbnormally(task, nse);
326          }          }
327    
328            assertEquals(1, task.setExceptionCount());
329            assertEquals(0, task.setCount());
330            tryToConfuseDoneTask(task);
331            checkCompletedAbnormally(task, nse);
332            assertEquals(0, task.runCount());
333      }      }
334    
335      /**      /**
336       * Cancelling before running succeeds       * cancel(false) before run succeeds
337       */       */
338      public void testCancelBeforeRun() {      public void testCancelBeforeRun() {
339          FutureTask task = new FutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
340          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
341          task.run();          task.run();
342            assertEquals(0, task.runCount());
343            assertEquals(0, task.setCount());
344            assertEquals(0, task.setExceptionCount());
345            assertTrue(task.isCancelled());
346            assertTrue(task.isDone());
347            tryToConfuseDoneTask(task);
348            assertEquals(0, task.runCount());
349          checkCancelled(task);          checkCancelled(task);
350      }      }
351    
352      /**      /**
353       * Cancel(true) before run succeeds       * cancel(true) before run succeeds
354       */       */
355      public void testCancelBeforeRun2() {      public void testCancelBeforeRun2() {
356          FutureTask task = new FutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
357          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
358          task.run();          task.run();
359            assertEquals(0, task.runCount());
360            assertEquals(0, task.setCount());
361            assertEquals(0, task.setExceptionCount());
362            assertTrue(task.isCancelled());
363            assertTrue(task.isDone());
364            tryToConfuseDoneTask(task);
365            assertEquals(0, task.runCount());
366          checkCancelled(task);          checkCancelled(task);
367      }      }
368    
369      /**      /**
370       * cancel of a completed task fails       * cancel(false) of a completed task fails
371       */       */
372      public void testCancelAfterRun() {      public void testCancelAfterRun() {
373          FutureTask task = new FutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
374          task.run();          task.run();
375          assertFalse(task.cancel(false));          assertFalse(task.cancel(false));
376            assertEquals(1, task.runCount());
377            assertEquals(1, task.setCount());
378            assertEquals(0, task.setExceptionCount());
379            tryToConfuseDoneTask(task);
380          checkCompletedNormally(task, Boolean.TRUE);          checkCompletedNormally(task, Boolean.TRUE);
381            assertEquals(1, task.runCount());
382      }      }
383    
384      /**      /**
385       * cancel(true) interrupts a running task       * cancel(true) of a completed task fails
386       */       */
387      public void testCancelInterrupt() throws InterruptedException {      public void testCancelAfterRun2() {
388          final CountDownLatch threadStarted = new CountDownLatch(1);          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
389          final FutureTask task =          task.run();
390              new FutureTask(new CheckedCallable<Object>() {          assertFalse(task.cancel(true));
391                  public Object realCall() {          assertEquals(1, task.runCount());
392                      threadStarted.countDown();          assertEquals(1, task.setCount());
393                      long t0 = System.nanoTime();          assertEquals(0, task.setExceptionCount());
394                      for (;;) {          tryToConfuseDoneTask(task);
395                          if (Thread.interrupted())          checkCompletedNormally(task, Boolean.TRUE);
396                              return Boolean.TRUE;          assertEquals(1, task.runCount());
                         if (millisElapsedSince(t0) > MEDIUM_DELAY_MS)  
                             fail("interrupt not delivered");  
                         Thread.yield();  
397                      }                      }
398    
399        /**
400         * cancel(true) interrupts a running task that subsequently succeeds
401         */
402        public void testCancelInterrupt() {
403            final CountDownLatch pleaseCancel = new CountDownLatch(1);
404            final PublicFutureTask task =
405                new PublicFutureTask(new CheckedRunnable() {
406                    public void realRun() {
407                        pleaseCancel.countDown();
408                        try {
409                            delay(LONG_DELAY_MS);
410                            shouldThrow();
411                        } catch (InterruptedException success) {}
412                  }});                  }});
413    
414          Thread t = newStartedThread(task);          Thread t = newStartedThread(task);
415          threadStarted.await();          await(pleaseCancel);
416          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
417          checkCancelled(task);          assertTrue(task.isCancelled());
418          awaitTermination(t, MEDIUM_DELAY_MS);          assertTrue(task.isDone());
419            awaitTermination(t);
420            assertEquals(1, task.runCount());
421            assertEquals(1, task.setCount());
422            assertEquals(0, task.setExceptionCount());
423            tryToConfuseDoneTask(task);
424          checkCancelled(task);          checkCancelled(task);
425      }      }
426    
427      /**      /**
428       * cancel(false) does not interrupt a running task       * cancel(true) tries to interrupt a running task, but
429         * Thread.interrupt throws (simulating a restrictive security
430         * manager)
431       */       */
432      public void testCancelNoInterrupt() throws InterruptedException {      public void testCancelInterrupt_ThrowsSecurityException() {
433          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseCancel = new CountDownLatch(1);
434          final CountDownLatch cancelled = new CountDownLatch(1);          final CountDownLatch cancelled = new CountDownLatch(1);
435          final FutureTask<Boolean> task =          final PublicFutureTask task =
436              new FutureTask<Boolean>(new CheckedCallable<Boolean>() {              new PublicFutureTask(new CheckedRunnable() {
437                  public Boolean realCall() throws InterruptedException {                  public void realRun() {
438                      threadStarted.countDown();                      pleaseCancel.countDown();
439                      cancelled.await(MEDIUM_DELAY_MS, MILLISECONDS);                      await(cancelled);
440                      assertFalse(Thread.interrupted());                      assertFalse(Thread.interrupted());
                     return Boolean.TRUE;  
441                  }});                  }});
442    
443          Thread t = newStartedThread(task);          final Thread t = new Thread(task) {
444          threadStarted.await();              // Simulate a restrictive security manager.
445          assertTrue(task.cancel(false));              @Override public void interrupt() {
446          checkCancelled(task);                  throw new SecurityException();
447                }};
448            t.setDaemon(true);
449            t.start();
450    
451            await(pleaseCancel);
452            try {
453                task.cancel(true);
454                shouldThrow();
455            } catch (SecurityException expected) {}
456    
457            // We failed to deliver the interrupt, but the world retains
458            // its sanity, as if we had done task.cancel(false)
459            assertTrue(task.isCancelled());
460            assertTrue(task.isDone());
461            assertEquals(1, task.runCount());
462            assertEquals(1, task.doneCount());
463            assertEquals(0, task.setCount());
464            assertEquals(0, task.setExceptionCount());
465          cancelled.countDown();          cancelled.countDown();
466          awaitTermination(t, MEDIUM_DELAY_MS);          awaitTermination(t);
467            assertEquals(1, task.setCount());
468            assertEquals(0, task.setExceptionCount());
469            tryToConfuseDoneTask(task);
470          checkCancelled(task);          checkCancelled(task);
471      }      }
472    
473      /**      /**
474       * run in one thread causes get in another thread to retrieve value       * cancel(true) interrupts a running task that subsequently throws
475       */       */
476      public void testGetRun() throws InterruptedException {      public void testCancelInterrupt_taskFails() {
477          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseCancel = new CountDownLatch(1);
478            final PublicFutureTask task =
479          final FutureTask task =              new PublicFutureTask(new Runnable() {
480              new FutureTask(new CheckedCallable<Object>() {                  public void run() {
481                  public Object realCall() throws InterruptedException {                      try {
482                      return Boolean.TRUE;                          pleaseCancel.countDown();
483                  }});                          delay(LONG_DELAY_MS);
484                            shouldThrow();
485          Thread t = newStartedThread(new CheckedRunnable() {                      } catch (Throwable t) {
486              public void realRun() throws Exception {                          assertTrue(t instanceof InterruptedException);
487                  threadStarted.countDown();                      }
488                  assertSame(Boolean.TRUE, task.get());                      throw new RuntimeException();
489              }});              }});
490    
491          threadStarted.await();          Thread t = newStartedThread(task);
492          checkNotDone(task);          await(pleaseCancel);
493          assertTrue(t.isAlive());          assertTrue(task.cancel(true));
494          task.run();          assertTrue(task.isCancelled());
495          checkCompletedNormally(task, Boolean.TRUE);          awaitTermination(t);
496          awaitTermination(t, MEDIUM_DELAY_MS);          assertEquals(1, task.runCount());
497            assertEquals(0, task.setCount());
498            assertEquals(1, task.setExceptionCount());
499            tryToConfuseDoneTask(task);
500            checkCancelled(task);
501      }      }
502    
503      /**      /**
504       * set in one thread causes get in another thread to retrieve value       * cancel(false) does not interrupt a running task
505       */       */
506      public void testGetSet() throws InterruptedException {      public void testCancelNoInterrupt() {
507          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseCancel = new CountDownLatch(1);
508            final CountDownLatch cancelled = new CountDownLatch(1);
509          final PublicFutureTask task =          final PublicFutureTask task =
510              new PublicFutureTask(new CheckedCallable<Object>() {              new PublicFutureTask(new CheckedCallable<Boolean>() {
511                  public Object realCall() throws InterruptedException {                  public Boolean realCall() {
512                        pleaseCancel.countDown();
513                        await(cancelled);
514                        assertFalse(Thread.interrupted());
515                      return Boolean.TRUE;                      return Boolean.TRUE;
516                  }});                  }});
517    
518          Thread t = newStartedThread(new CheckedRunnable() {          Thread t = newStartedThread(task);
519              public void realRun() throws Exception {          await(pleaseCancel);
520                  threadStarted.countDown();          assertTrue(task.cancel(false));
521                  assertSame(Boolean.FALSE, task.get());          assertTrue(task.isCancelled());
522              }});          cancelled.countDown();
523            awaitTermination(t);
524          threadStarted.await();          assertEquals(1, task.runCount());
525          checkNotDone(task);          assertEquals(1, task.setCount());
526          assertTrue(t.isAlive());          assertEquals(0, task.setExceptionCount());
527          task.set(Boolean.FALSE);          tryToConfuseDoneTask(task);
528          checkCompletedNormally(task, Boolean.FALSE);          checkCancelled(task);
         awaitTermination(t, MEDIUM_DELAY_MS);  
529      }      }
530    
531      /**      /**
532       * run in one thread causes timed get in another thread to retrieve value       * run in one thread causes get in another thread to retrieve value
533       */       */
534      public void testTimedGetRun() throws InterruptedException {      public void testGetRun() {
535          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseRun = new CountDownLatch(2);
536    
537          final FutureTask task =          final PublicFutureTask task =
538              new FutureTask(new CheckedCallable<Object>() {              new PublicFutureTask(new CheckedCallable<Object>() {
539                  public Object realCall() throws InterruptedException {                  public Object realCall() {
540                      return Boolean.TRUE;                      return two;
541                  }});                  }});
542    
543          Thread t = newStartedThread(new CheckedRunnable() {          Thread t1 = newStartedThread(new CheckedRunnable() {
544              public void realRun() throws Exception {              public void realRun() throws Exception {
545                  threadStarted.countDown();                  pleaseRun.countDown();
546                  assertSame(Boolean.TRUE,                  assertSame(two, task.get());
                            task.get(MEDIUM_DELAY_MS, MILLISECONDS));  
547              }});              }});
548    
549          threadStarted.await();          Thread t2 = newStartedThread(new CheckedRunnable() {
550                public void realRun() throws Exception {
551                    pleaseRun.countDown();
552                    assertSame(two, task.get(2*LONG_DELAY_MS, MILLISECONDS));
553                }});
554    
555            await(pleaseRun);
556          checkNotDone(task);          checkNotDone(task);
557          assertTrue(t.isAlive());          assertTrue(t1.isAlive());
558            assertTrue(t2.isAlive());
559          task.run();          task.run();
560          checkCompletedNormally(task, Boolean.TRUE);          checkCompletedNormally(task, two);
561          awaitTermination(t, MEDIUM_DELAY_MS);          assertEquals(1, task.runCount());
562            assertEquals(1, task.setCount());
563            assertEquals(0, task.setExceptionCount());
564            awaitTermination(t1);
565            awaitTermination(t2);
566            tryToConfuseDoneTask(task);
567            checkCompletedNormally(task, two);
568      }      }
569    
570      /**      /**
571       * set in one thread causes timed get in another thread to retrieve value       * set in one thread causes get in another thread to retrieve value
572       */       */
573      public void testTimedGetSet() throws InterruptedException {      public void testGetSet() {
574          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseSet = new CountDownLatch(2);
575    
576          final PublicFutureTask task =          final PublicFutureTask task =
577              new PublicFutureTask(new CheckedCallable<Object>() {              new PublicFutureTask(new CheckedCallable<Object>() {
578                  public Object realCall() throws InterruptedException {                  public Object realCall() throws InterruptedException {
579                      return Boolean.TRUE;                      return two;
580                  }});                  }});
581    
582          Thread t = newStartedThread(new CheckedRunnable() {          Thread t1 = newStartedThread(new CheckedRunnable() {
583                public void realRun() throws Exception {
584                    pleaseSet.countDown();
585                    assertSame(two, task.get());
586                }});
587    
588            Thread t2 = newStartedThread(new CheckedRunnable() {
589              public void realRun() throws Exception {              public void realRun() throws Exception {
590                  threadStarted.countDown();                  pleaseSet.countDown();
591                  assertSame(Boolean.FALSE,                  assertSame(two, task.get(2*LONG_DELAY_MS, MILLISECONDS));
                            task.get(MEDIUM_DELAY_MS, MILLISECONDS));  
592              }});              }});
593    
594          threadStarted.await();          await(pleaseSet);
595          checkNotDone(task);          checkNotDone(task);
596          assertTrue(t.isAlive());          assertTrue(t1.isAlive());
597          task.set(Boolean.FALSE);          assertTrue(t2.isAlive());
598          checkCompletedNormally(task, Boolean.FALSE);          task.set(two);
599          awaitTermination(t, MEDIUM_DELAY_MS);          assertEquals(0, task.runCount());
600            assertEquals(1, task.setCount());
601            assertEquals(0, task.setExceptionCount());
602            tryToConfuseDoneTask(task);
603            checkCompletedNormally(task, two);
604            awaitTermination(t1);
605            awaitTermination(t2);
606      }      }
607    
608      /**      /**
609       * Cancelling a task causes timed get in another thread to throw       * Cancelling a task causes timed get in another thread to throw
610       * CancellationException       * CancellationException
611       */       */
612      public void testTimedGet_Cancellation() throws InterruptedException {      public void testTimedGet_Cancellation() {
613          final CountDownLatch threadStarted = new CountDownLatch(2);          testTimedGet_Cancellation(false);
         final FutureTask task =  
             new FutureTask(new CheckedInterruptedCallable<Object>() {  
                 public Object realCall() throws InterruptedException {  
                     threadStarted.countDown();  
                     delay(LONG_DELAY_MS);  
                     return Boolean.TRUE;  
                 }});  
   
         Thread t1 = new ThreadShouldThrow(CancellationException.class) {  
             public void realRun() throws Exception {  
                 threadStarted.countDown();  
                 task.get(MEDIUM_DELAY_MS, MILLISECONDS);  
             }};  
         Thread t2 = new Thread(task);  
         t1.start();  
         t2.start();  
         threadStarted.await();  
         task.cancel(true);  
         awaitTermination(t1, MEDIUM_DELAY_MS);  
         awaitTermination(t2, MEDIUM_DELAY_MS);  
         checkCancelled(task);  
614      }      }
615        public void testTimedGet_Cancellation_interrupt() {
616      /**          testTimedGet_Cancellation(true);
617       * Cancelling a task causes get in another thread to throw      }
618       * CancellationException      public void testTimedGet_Cancellation(final boolean mayInterruptIfRunning) {
619       */          final CountDownLatch pleaseCancel = new CountDownLatch(3);
620      public void testGet_Cancellation() throws InterruptedException {          final CountDownLatch cancelled = new CountDownLatch(1);
621          final CountDownLatch threadStarted = new CountDownLatch(2);          final Callable<Object> callable =
622          final FutureTask task =              new CheckedCallable<Object>() {
             new FutureTask(new CheckedInterruptedCallable<Object>() {  
623                  public Object realCall() throws InterruptedException {                  public Object realCall() throws InterruptedException {
624                      threadStarted.countDown();                  pleaseCancel.countDown();
625                      delay(LONG_DELAY_MS);                  if (mayInterruptIfRunning) {
626                      return Boolean.TRUE;                      try {
627                  }});                          delay(2*LONG_DELAY_MS);
628                        } catch (InterruptedException success) {}
629                    } else {
630                        await(cancelled);
631                    }
632                    return two;
633                }};
634            final PublicFutureTask task = new PublicFutureTask(callable);
635    
636          Thread t1 = new ThreadShouldThrow(CancellationException.class) {          Thread t1 = new ThreadShouldThrow(CancellationException.class) {
637              public void realRun() throws Exception {              public void realRun() throws Exception {
638                  threadStarted.countDown();                      pleaseCancel.countDown();
639                  task.get();                  task.get();
640              }};              }};
641          Thread t2 = new Thread(task);          Thread t2 = new ThreadShouldThrow(CancellationException.class) {
642                    public void realRun() throws Exception {
643                        pleaseCancel.countDown();
644                        task.get(2*LONG_DELAY_MS, MILLISECONDS);
645                    }};
646          t1.start();          t1.start();
647          t2.start();          t2.start();
648          threadStarted.await();          Thread t3 = newStartedThread(task);
649          task.cancel(true);          await(pleaseCancel);
650          awaitTermination(t1, MEDIUM_DELAY_MS);          checkIsRunning(task);
651          awaitTermination(t2, MEDIUM_DELAY_MS);          task.cancel(mayInterruptIfRunning);
652            checkCancelled(task);
653            awaitTermination(t1);
654            awaitTermination(t2);
655            cancelled.countDown();
656            awaitTermination(t3);
657            assertEquals(1, task.runCount());
658            assertEquals(1, task.setCount());
659            assertEquals(0, task.setExceptionCount());
660            tryToConfuseDoneTask(task);
661          checkCancelled(task);          checkCancelled(task);
662      }      }
663    
# Line 423  Line 665 
665       * A runtime exception in task causes get to throw ExecutionException       * A runtime exception in task causes get to throw ExecutionException
666       */       */
667      public void testGet_ExecutionException() throws InterruptedException {      public void testGet_ExecutionException() throws InterruptedException {
668          final FutureTask task = new FutureTask(new Callable() {          final ArithmeticException e = new ArithmeticException();
669            final PublicFutureTask task = new PublicFutureTask(new Callable() {
670              public Object call() {              public Object call() {
671                  return 5/0;                  throw e;
672              }});              }});
673    
674          task.run();          task.run();
675            assertEquals(1, task.runCount());
676            assertEquals(0, task.setCount());
677            assertEquals(1, task.setExceptionCount());
678          try {          try {
679              task.get();              task.get();
680              shouldThrow();              shouldThrow();
681          } catch (ExecutionException success) {          } catch (ExecutionException success) {
682              assertTrue(success.getCause() instanceof ArithmeticException);              assertSame(e, success.getCause());
683                tryToConfuseDoneTask(task);
684              checkCompletedAbnormally(task, success.getCause());              checkCompletedAbnormally(task, success.getCause());
685          }          }
686      }      }
# Line 442  Line 689 
689       * A runtime exception in task causes timed get to throw ExecutionException       * A runtime exception in task causes timed get to throw ExecutionException
690       */       */
691      public void testTimedGet_ExecutionException2() throws Exception {      public void testTimedGet_ExecutionException2() throws Exception {
692          final FutureTask task = new FutureTask(new Callable() {          final ArithmeticException e = new ArithmeticException();
693            final PublicFutureTask task = new PublicFutureTask(new Callable() {
694              public Object call() {              public Object call() {
695                  return 5/0;                  throw e;
696              }});              }});
697    
698          task.run();          task.run();
699          try {          try {
700              task.get(SHORT_DELAY_MS, MILLISECONDS);              task.get(LONG_DELAY_MS, MILLISECONDS);
701              shouldThrow();              shouldThrow();
702          } catch (ExecutionException success) {          } catch (ExecutionException success) {
703              assertTrue(success.getCause() instanceof ArithmeticException);              assertSame(e, success.getCause());
704                tryToConfuseDoneTask(task);
705              checkCompletedAbnormally(task, success.getCause());              checkCompletedAbnormally(task, success.getCause());
706          }          }
707      }      }
708    
709      /**      /**
710       * Interrupting a waiting get causes it to throw InterruptedException       * get is interruptible
711       */       */
712      public void testGet_InterruptedException() throws InterruptedException {      public void testGet_interruptible() {
713          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
714          final FutureTask task = new FutureTask(new NoOpCallable());          final FutureTask task = new FutureTask(new NoOpCallable());
715          Thread t = newStartedThread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
716              public void realRun() throws Exception {              public void realRun() throws Exception {
717                  threadStarted.countDown();                  Thread.currentThread().interrupt();
718                    try {
719                  task.get();                  task.get();
720                        shouldThrow();
721                    } catch (InterruptedException success) {}
722                    assertFalse(Thread.interrupted());
723    
724                    pleaseInterrupt.countDown();
725                    try {
726                        task.get();
727                        shouldThrow();
728                    } catch (InterruptedException success) {}
729                    assertFalse(Thread.interrupted());
730              }});              }});
731    
732          threadStarted.await();          await(pleaseInterrupt);
733          t.interrupt();          t.interrupt();
734          awaitTermination(t, MEDIUM_DELAY_MS);          awaitTermination(t);
735          checkNotDone(task);          checkNotDone(task);
736      }      }
737    
738      /**      /**
739       * Interrupting a waiting timed get causes it to throw InterruptedException       * timed get is interruptible
740       */       */
741      public void testTimedGet_InterruptedException2() throws InterruptedException {      public void testTimedGet_interruptible() {
742          final CountDownLatch threadStarted = new CountDownLatch(1);          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
743          final FutureTask task = new FutureTask(new NoOpCallable());          final FutureTask task = new FutureTask(new NoOpCallable());
744          Thread t = newStartedThread(new CheckedInterruptedRunnable() {          Thread t = newStartedThread(new CheckedRunnable() {
745              public void realRun() throws Exception {              public void realRun() throws Exception {
746                  threadStarted.countDown();                  Thread.currentThread().interrupt();
747                  task.get(LONG_DELAY_MS, MILLISECONDS);                  try {
748                        task.get(2*LONG_DELAY_MS, MILLISECONDS);
749                        shouldThrow();
750                    } catch (InterruptedException success) {}
751                    assertFalse(Thread.interrupted());
752    
753                    pleaseInterrupt.countDown();
754                    try {
755                        task.get(2*LONG_DELAY_MS, MILLISECONDS);
756                        shouldThrow();
757                    } catch (InterruptedException success) {}
758                    assertFalse(Thread.interrupted());
759              }});              }});
760    
761          threadStarted.await();          await(pleaseInterrupt);
762          t.interrupt();          t.interrupt();
763          awaitTermination(t, MEDIUM_DELAY_MS);          awaitTermination(t);
764          checkNotDone(task);          checkNotDone(task);
765      }      }
766    
# Line 497  Line 768 
768       * A timed out timed get throws TimeoutException       * A timed out timed get throws TimeoutException
769       */       */
770      public void testGet_TimeoutException() throws Exception {      public void testGet_TimeoutException() throws Exception {
771            FutureTask task = new FutureTask(new NoOpCallable());
772            long startTime = System.nanoTime();
773          try {          try {
774                task.get(timeoutMillis(), MILLISECONDS);
775                shouldThrow();
776            } catch (TimeoutException success) {
777                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
778            }
779        }
780    
781        /**
782         * timed get with null TimeUnit throws NullPointerException
783         */
784        public void testGet_NullTimeUnit() throws Exception {
785              FutureTask task = new FutureTask(new NoOpCallable());              FutureTask task = new FutureTask(new NoOpCallable());
786              task.get(1, MILLISECONDS);          long[] timeouts = { Long.MIN_VALUE, 0L, Long.MAX_VALUE };
787    
788            for (long timeout : timeouts) {
789                try {
790                    task.get(timeout, null);
791              shouldThrow();              shouldThrow();
792          } catch (TimeoutException success) {}              } catch (NullPointerException success) {}
793            }
794    
795            task.run();
796    
797            for (long timeout : timeouts) {
798                try {
799                    task.get(timeout, null);
800                    shouldThrow();
801                } catch (NullPointerException success) {}
802            }
803      }      }
804    
805  }  }

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.37

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8