[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.31, Sat Dec 15 21:50:30 2012 UTC revision 1.42, Sat Feb 28 18:18:56 2015 UTC
# Line 6  Line 6 
6   * Pat Fisher, Mike Judd.   * Pat Fisher, Mike Judd.
7   */   */
8    
9  import junit.framework.*;  import static java.util.concurrent.TimeUnit.MILLISECONDS;
10    import static java.util.concurrent.TimeUnit.NANOSECONDS;
11    import static java.util.concurrent.TimeUnit.SECONDS;
12    
13    import java.util.ArrayList;
14    import java.util.List;
15    import java.util.NoSuchElementException;
16  import java.util.concurrent.Callable;  import java.util.concurrent.Callable;
17  import java.util.concurrent.CancellationException;  import java.util.concurrent.CancellationException;
18  import java.util.concurrent.CountDownLatch;  import java.util.concurrent.CountDownLatch;
19  import java.util.concurrent.ExecutionException;  import java.util.concurrent.ExecutionException;
20    import java.util.concurrent.Executors;
21    import java.util.concurrent.ExecutorService;
22  import java.util.concurrent.Future;  import java.util.concurrent.Future;
23  import java.util.concurrent.FutureTask;  import java.util.concurrent.FutureTask;
24  import java.util.concurrent.TimeoutException;  import java.util.concurrent.TimeoutException;
25  import java.util.concurrent.atomic.AtomicInteger;  import java.util.concurrent.atomic.AtomicInteger;
26  import static java.util.concurrent.TimeUnit.MILLISECONDS;  
27  import static java.util.concurrent.TimeUnit.SECONDS;  import junit.framework.Test;
28  import java.util.*;  import junit.framework.TestSuite;
29    
30  public class FutureTaskTest extends JSR166TestCase {  public class FutureTaskTest extends JSR166TestCase {
31    
# Line 37  Line 45 
45              assertEquals(1, pf.doneCount());              assertEquals(1, pf.doneCount());
46              assertFalse(pf.runAndReset());              assertFalse(pf.runAndReset());
47              assertEquals(1, pf.doneCount());              assertEquals(1, pf.doneCount());
48                Object r = null; Object exInfo = null;
49                try {
50                    r = f.get();
51                } catch (CancellationException t) {
52                    exInfo = CancellationException.class;
53                } catch (ExecutionException t) {
54                    exInfo = t.getCause();
55                } catch (Throwable t) {
56                    threadUnexpectedException(t);
57                }
58    
59              // Check that run and runAndReset have no effect.              // Check that run and runAndReset have no effect.
60              int savedRunCount = pf.runCount();              int savedRunCount = pf.runCount();
             int savedSetCount = pf.setCount();  
             int savedSetExceptionCount = pf.setExceptionCount();  
61              pf.run();              pf.run();
62              pf.runAndReset();              pf.runAndReset();
63              assertEquals(savedRunCount, pf.runCount());              assertEquals(savedRunCount, pf.runCount());
64              assertEquals(savedSetCount, pf.setCount());              try {
65              assertEquals(savedSetExceptionCount, pf.setExceptionCount());                  assertSame(r, f.get());
66                } catch (CancellationException t) {
67                    assertSame(exInfo, CancellationException.class);
68                } catch (ExecutionException t) {
69                    assertSame(exInfo, t.getCause());
70                } catch (Throwable t) {
71                    threadUnexpectedException(t);
72                }
73              assertTrue(f.isDone());              assertTrue(f.isDone());
74          }          }
75      }      }
# Line 68  Line 91 
91              FutureTask ft = (FutureTask<?>) f;              FutureTask ft = (FutureTask<?>) f;
92              // Check that run methods do nothing              // Check that run methods do nothing
93              ft.run();              ft.run();
94              if (f instanceof PublicFutureTask)              if (f instanceof PublicFutureTask) {
95                  assertFalse(((PublicFutureTask) f).runAndReset());                  PublicFutureTask pf = (PublicFutureTask) f;
96                    int savedRunCount = pf.runCount();
97                    pf.run();
98                    assertFalse(pf.runAndReset());
99                    assertEquals(savedRunCount, pf.runCount());
100                }
101              checkNotDone(f);              checkNotDone(f);
102          }          }
103      }      }
# Line 107  Line 135 
135          pf.set(new Object());          pf.set(new Object());
136          pf.setException(new Error());          pf.setException(new Error());
137          for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {          for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
138              pf.cancel(true);              pf.cancel(mayInterruptIfRunning);
139          }          }
140      }      }
141    
# Line 319  Line 347 
347          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
348          assertTrue(task.cancel(false));          assertTrue(task.cancel(false));
349          task.run();          task.run();
350            assertEquals(0, task.runCount());
351          assertEquals(0, task.setCount());          assertEquals(0, task.setCount());
352          assertEquals(0, task.setExceptionCount());          assertEquals(0, task.setExceptionCount());
353            assertTrue(task.isCancelled());
354            assertTrue(task.isDone());
355          tryToConfuseDoneTask(task);          tryToConfuseDoneTask(task);
         checkCancelled(task);  
356          assertEquals(0, task.runCount());          assertEquals(0, task.runCount());
357            checkCancelled(task);
358      }      }
359    
360      /**      /**
# Line 333  Line 364 
364          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
365          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
366          task.run();          task.run();
367            assertEquals(0, task.runCount());
368          assertEquals(0, task.setCount());          assertEquals(0, task.setCount());
369          assertEquals(0, task.setExceptionCount());          assertEquals(0, task.setExceptionCount());
370            assertTrue(task.isCancelled());
371            assertTrue(task.isDone());
372          tryToConfuseDoneTask(task);          tryToConfuseDoneTask(task);
         checkCancelled(task);  
373          assertEquals(0, task.runCount());          assertEquals(0, task.runCount());
374            checkCancelled(task);
375      }      }
376    
377      /**      /**
# Line 347  Line 381 
381          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
382          task.run();          task.run();
383          assertFalse(task.cancel(false));          assertFalse(task.cancel(false));
384            assertEquals(1, task.runCount());
385          assertEquals(1, task.setCount());          assertEquals(1, task.setCount());
386          assertEquals(0, task.setExceptionCount());          assertEquals(0, task.setExceptionCount());
387          tryToConfuseDoneTask(task);          tryToConfuseDoneTask(task);
# Line 361  Line 396 
396          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
397          task.run();          task.run();
398          assertFalse(task.cancel(true));          assertFalse(task.cancel(true));
399            assertEquals(1, task.runCount());
400          assertEquals(1, task.setCount());          assertEquals(1, task.setCount());
401          assertEquals(0, task.setExceptionCount());          assertEquals(0, task.setExceptionCount());
402          tryToConfuseDoneTask(task);          tryToConfuseDoneTask(task);
# Line 387  Line 423 
423          await(pleaseCancel);          await(pleaseCancel);
424          assertTrue(task.cancel(true));          assertTrue(task.cancel(true));
425          assertTrue(task.isCancelled());          assertTrue(task.isCancelled());
426            assertTrue(task.isDone());
427          awaitTermination(t);          awaitTermination(t);
428          assertEquals(1, task.runCount());          assertEquals(1, task.runCount());
429          assertEquals(1, task.setCount());          assertEquals(1, task.setCount());
# Line 396  Line 433 
433      }      }
434    
435      /**      /**
436         * cancel(true) tries to interrupt a running task, but
437         * Thread.interrupt throws (simulating a restrictive security
438         * manager)
439         */
440        public void testCancelInterrupt_ThrowsSecurityException() {
441            final CountDownLatch pleaseCancel = new CountDownLatch(1);
442            final CountDownLatch cancelled = new CountDownLatch(1);
443            final PublicFutureTask task =
444                new PublicFutureTask(new CheckedRunnable() {
445                    public void realRun() {
446                        pleaseCancel.countDown();
447                        await(cancelled);
448                        assertFalse(Thread.interrupted());
449                    }});
450    
451            final Thread t = new Thread(task) {
452                // Simulate a restrictive security manager.
453                @Override public void interrupt() {
454                    throw new SecurityException();
455                }};
456            t.setDaemon(true);
457            t.start();
458    
459            await(pleaseCancel);
460            try {
461                task.cancel(true);
462                shouldThrow();
463            } catch (SecurityException expected) {}
464    
465            // We failed to deliver the interrupt, but the world retains
466            // its sanity, as if we had done task.cancel(false)
467            assertTrue(task.isCancelled());
468            assertTrue(task.isDone());
469            assertEquals(1, task.runCount());
470            assertEquals(1, task.doneCount());
471            assertEquals(0, task.setCount());
472            assertEquals(0, task.setExceptionCount());
473            cancelled.countDown();
474            awaitTermination(t);
475            assertEquals(1, task.setCount());
476            assertEquals(0, task.setExceptionCount());
477            tryToConfuseDoneTask(task);
478            checkCancelled(task);
479        }
480    
481        /**
482       * cancel(true) interrupts a running task that subsequently throws       * cancel(true) interrupts a running task that subsequently throws
483       */       */
484      public void testCancelInterrupt_taskFails() {      public void testCancelInterrupt_taskFails() {
# Line 403  Line 486 
486          final PublicFutureTask task =          final PublicFutureTask task =
487              new PublicFutureTask(new Runnable() {              new PublicFutureTask(new Runnable() {
488                  public void run() {                  public void run() {
                     try {  
489                          pleaseCancel.countDown();                          pleaseCancel.countDown();
490                        try {
491                          delay(LONG_DELAY_MS);                          delay(LONG_DELAY_MS);
492                      } finally { throw new RuntimeException(); }                          threadShouldThrow();
493                        } catch (InterruptedException success) {
494                        } catch (Throwable t) { threadUnexpectedException(t); }
495                        throw new RuntimeException();
496                  }});                  }});
497    
498          Thread t = newStartedThread(task);          Thread t = newStartedThread(task);
# Line 531  Line 617 
617       * CancellationException       * CancellationException
618       */       */
619      public void testTimedGet_Cancellation() {      public void testTimedGet_Cancellation() {
620          for (final boolean mayInterruptIfRunning :          testTimedGet_Cancellation(false);
621                   new boolean[] { true, false }) {      }
622        public void testTimedGet_Cancellation_interrupt() {
623            testTimedGet_Cancellation(true);
624        }
625        public void testTimedGet_Cancellation(final boolean mayInterruptIfRunning) {
626              final CountDownLatch pleaseCancel = new CountDownLatch(3);              final CountDownLatch pleaseCancel = new CountDownLatch(3);
627              final CountDownLatch cancelled = new CountDownLatch(1);              final CountDownLatch cancelled = new CountDownLatch(1);
628              final PublicFutureTask task =          final Callable<Object> callable =
629                  new PublicFutureTask(new CheckedCallable<Object>() {              new CheckedCallable<Object>() {
630                      public Object realCall() throws InterruptedException {                      public Object realCall() throws InterruptedException {
631                          pleaseCancel.countDown();                          pleaseCancel.countDown();
632                          if (mayInterruptIfRunning) {                          if (mayInterruptIfRunning) {
# Line 547  Line 637 
637                              await(cancelled);                              await(cancelled);
638                          }                          }
639                          return two;                          return two;
640                      }});              }};
641            final PublicFutureTask task = new PublicFutureTask(callable);
642    
643              Thread t1 = new ThreadShouldThrow(CancellationException.class) {              Thread t1 = new ThreadShouldThrow(CancellationException.class) {
644                  public void realRun() throws Exception {                  public void realRun() throws Exception {
# Line 576  Line 667 
667              tryToConfuseDoneTask(task);              tryToConfuseDoneTask(task);
668              checkCancelled(task);              checkCancelled(task);
669          }          }
     }  
670    
671      /**      /**
672       * A runtime exception in task causes get to throw ExecutionException       * A runtime exception in task causes get to throw ExecutionException
# Line 719  Line 809 
809          }          }
810      }      }
811    
812        /**
813         * timed get with most negative timeout works correctly (i.e. no
814         * underflow bug)
815         */
816        public void testGet_NegativeInfinityTimeout() throws Exception {
817            final ExecutorService pool = Executors.newFixedThreadPool(10);
818            final Runnable nop = new Runnable() { public void run() {}};
819            final FutureTask<Void> task = new FutureTask<>(nop, null);
820            final List<Future<?>> futures = new ArrayList<>();
821            Runnable r = new Runnable() { public void run() {
822                for (long timeout : new long[] { 0L, -1L, Long.MIN_VALUE }) {
823                    try {
824                        task.get(timeout, NANOSECONDS);
825                        shouldThrow();
826                    } catch (TimeoutException success) {
827                    } catch (Throwable fail) {threadUnexpectedException(fail);}}}};
828            for (int i = 0; i < 10; i++)
829                futures.add(pool.submit(r));
830            try {
831                joinPool(pool);
832                for (Future<?> future : futures)
833                    checkCompletedNormally(future, null);
834            } finally {
835                task.run();         // last resort to help terminate
836            }
837        }
838    
839  }  }

Legend:
Removed from v.1.31  
changed lines
  Added in v.1.42

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8