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

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.47

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8