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

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8