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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8