code: // from gee.cs.oswego.edu/home/jsr166/jsr166
  
  package jsr166tests.tck;
  
  /*
   * Written by Doug Lea with assistance from members of JCP JSR-166
   * Expert Group and released to the public domain, as explained at
   * http://creativecommons.org/licenses/publicdomain
   * Other contributors include Andrew Wright, Jeffrey Hayes,
   * Pat Fisher, Mike Judd.
   */
  
  import junit.framework.*;
  import java.util.concurrent.*;
  import static java.util.concurrent.TimeUnit.MILLISECONDS;
  import java.util.*;
  
  public class FutureTaskTest extends JSR166TestCase {
  
      public static void main(String[] args) {
          junit.textui.TestRunner.run (suite());
      }
      public static Test suite() {
          return new TestSuite(FutureTaskTest.class);
      }
  
      /**
       * Subclass to expose protected methods
       */
      static class PublicFutureTask extends FutureTask {
          public PublicFutureTask(Callable r) { super(r); }
          public boolean runAndReset() { return super.runAndReset(); }
          public void set(Object x) { super.set(x); }
          public void setException(Throwable t) { super.setException(t); }
      }
  
      /**
       * Creating a future with a null callable throws NPE
       */
      public void testConstructor() {
          try {
              FutureTask task = new FutureTask(null);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * creating a future with null runnable fails
       */
      public void testConstructor2() {
          try {
              FutureTask task = new FutureTask(null, Boolean.TRUE);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * isDone is true when a task completes
       */
      public void testIsDone() {
          FutureTask task = new FutureTask(new NoOpCallable());
          task.run();
          assertTrue(task.isDone());
          assertFalse(task.isCancelled());
      }
  
      /**
       * runAndReset of a non-cancelled task succeeds
       */
      public void testRunAndReset() {
          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
          assertTrue(task.runAndReset());
          assertFalse(task.isDone());
      }
  
      /**
       * runAndReset after cancellation fails
       */
      public void testResetAfterCancel() {
          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
          assertTrue(task.cancel(false));
          assertFalse(task.runAndReset());
          assertTrue(task.isDone());
          assertTrue(task.isCancelled());
      }
  
  
  
      /**
       * setting value causes get to return it
       */
      public void testSet() throws Exception {
          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
          task.set(one);
          assertSame(task.get(), one);
      }
  
      /**
       * setException causes get to throw ExecutionException
       */
      public void testSetException() throws Exception {
          Exception nse = new NoSuchElementException();
          PublicFutureTask task = new PublicFutureTask(new NoOpCallable());
          task.setException(nse);
          try {
              Object x = task.get();
              shouldThrow();
          } catch (ExecutionException success) {
              assertSame(success.getCause(), nse);
          }
      }
  
      /**
       *  Cancelling before running succeeds
       */
      public void testCancelBeforeRun() {
          FutureTask task = new FutureTask(new NoOpCallable());
          assertTrue(task.cancel(false));
          task.run();
          assertTrue(task.isDone());
          assertTrue(task.isCancelled());
      }
  
      /**
       * Cancel(true) before run succeeds
       */
      public void testCancelBeforeRun2() {
          FutureTask task = new FutureTask(new NoOpCallable());
          assertTrue(task.cancel(true));
          task.run();
          assertTrue(task.isDone());
          assertTrue(task.isCancelled());
      }
  
      /**
       * cancel of a completed task fails
       */
      public void testCancelAfterRun() {
          FutureTask task = new FutureTask(new NoOpCallable());
          task.run();
          assertFalse(task.cancel(false));
          assertTrue(task.isDone());
          assertFalse(task.isCancelled());
      }
  
      /**
       * cancel(true) interrupts a running task
       */
      public void testCancelInterrupt() throws InterruptedException {
          final FutureTask task =
              new FutureTask(new CheckedInterruptedCallable<Object>() {
                  public Object realCall() throws InterruptedException {
                      Thread.sleep(SMALL_DELAY_MS);
                      return Boolean.TRUE;
                  }});
  
          Thread t = new Thread(task);
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          assertTrue(task.cancel(true));
          t.join();
          assertTrue(task.isDone());
          assertTrue(task.isCancelled());
      }
  
  
      /**
       * cancel(false) does not interrupt a running task
       */
      public void testCancelNoInterrupt() throws InterruptedException {
          final FutureTask task =
              new FutureTask(new CheckedCallable<Object>() {
                  public Object realCall() throws InterruptedException {
                      Thread.sleep(MEDIUM_DELAY_MS);
                      return Boolean.TRUE;
                  }});
  
          Thread t = new Thread(task);
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          assertTrue(task.cancel(false));
          t.join();
          assertTrue(task.isDone());
          assertTrue(task.isCancelled());
      }
  
      /**
       * set in one thread causes get in another thread to retrieve value
       */
      public void testGet1() throws InterruptedException {
          final FutureTask ft =
              new FutureTask(new CheckedCallable<Object>() {
                  public Object realCall() throws InterruptedException {
                      return Boolean.TRUE;
                  }});
          Thread t = new Thread(new CheckedRunnable() {
              public void realRun() throws Exception {
                  assertSame(Boolean.TRUE, ft.get());
              }});
  
          assertFalse(ft.isDone());
          assertFalse(ft.isCancelled());
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          ft.run();
          t.join();
          assertTrue(ft.isDone());
          assertFalse(ft.isCancelled());
      }
  
      /**
       * set in one thread causes timed get in another thread to retrieve value
       */
      public void testTimedGet1() throws InterruptedException {
          final FutureTask ft =
              new FutureTask(new CheckedCallable<Object>() {
                  public Object realCall() throws InterruptedException {
                      return Boolean.TRUE;
                  }});
          Thread t = new Thread(new CheckedRunnable() {
              public void realRun() throws Exception {
                  assertSame(Boolean.TRUE, ft.get(SMALL_DELAY_MS, MILLISECONDS));
              }});
  
          assertFalse(ft.isDone());
          assertFalse(ft.isCancelled());
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          ft.run();
          t.join();
          assertTrue(ft.isDone());
          assertFalse(ft.isCancelled());
      }
  
      /**
       *  Cancelling a task causes timed get in another thread to throw CancellationException
       */
      public void testTimedGet_Cancellation() throws InterruptedException {
          final FutureTask ft =
              new FutureTask(new CheckedInterruptedCallable<Object>() {
                  public Object realCall() throws InterruptedException {
                      Thread.sleep(SMALL_DELAY_MS);
                      return Boolean.TRUE;
                  }});
  
          Thread t1 = new ThreadShouldThrow(CancellationException.class) {
              public void realRun() throws Exception {
                  ft.get(MEDIUM_DELAY_MS, MILLISECONDS);
              }};
          Thread t2 = new Thread(ft);
          t1.start();
          t2.start();
          Thread.sleep(SHORT_DELAY_MS);
          ft.cancel(true);
          t1.join();
          t2.join();
      }
  
      /**
       * Cancelling a task causes get in another thread to throw CancellationException
       */
      public void testGet_Cancellation() throws InterruptedException {
          final FutureTask ft =
              new FutureTask(new CheckedInterruptedCallable<Object>() {
                  public Object realCall() throws InterruptedException {
                      Thread.sleep(SMALL_DELAY_MS);
                      return Boolean.TRUE;
                  }});
          Thread t1 = new ThreadShouldThrow(CancellationException.class) {
              public void realRun() throws Exception {
                  ft.get();
              }};
  
          Thread t2 = new Thread(ft);
          t1.start();
          t2.start();
          Thread.sleep(SHORT_DELAY_MS);
          ft.cancel(true);
          t1.join();
          t2.join();
      }
  
  
      /**
       * A runtime exception in task causes get to throw ExecutionException
       */
      public void testGet_ExecutionException() throws InterruptedException {
          final FutureTask ft = new FutureTask(new Callable() {
              public Object call() {
                  return 5/0;
              }});
  
          ft.run();
          try {
              ft.get();
              shouldThrow();
          } catch (ExecutionException success) {
              assertTrue(success.getCause() instanceof ArithmeticException);
          }
      }
  
      /**
       *  A runtime exception in task causes timed get to throw ExecutionException
       */
      public void testTimedGet_ExecutionException2() throws Exception {
          final FutureTask ft = new FutureTask(new Callable() {
              public Object call() {
                  return 5/0;
              }});
  
          ft.run();
          try {
              ft.get(SHORT_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (ExecutionException success) {
              assertTrue(success.getCause() instanceof ArithmeticException);
          }
      }
  
  
      /**
       * Interrupting a waiting get causes it to throw InterruptedException
       */
      public void testGet_InterruptedException() throws InterruptedException {
          final FutureTask ft = new FutureTask(new NoOpCallable());
          Thread t = new Thread(new CheckedInterruptedRunnable() {
              public void realRun() throws Exception {
                  ft.get();
              }});
  
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          t.interrupt();
          t.join();
      }
  
      /**
       *  Interrupting a waiting timed get causes it to throw InterruptedException
       */
      public void testTimedGet_InterruptedException2() throws InterruptedException {
          final FutureTask ft = new FutureTask(new NoOpCallable());
          Thread t = new Thread(new CheckedInterruptedRunnable() {
              public void realRun() throws Exception {
                  ft.get(LONG_DELAY_MS,MILLISECONDS);
              }});
  
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          t.interrupt();
          t.join();
      }
  
      /**
       * A timed out timed get throws TimeoutException
       */
      public void testGet_TimeoutException() throws Exception {
          try {
              FutureTask ft = new FutureTask(new NoOpCallable());
              ft.get(1,MILLISECONDS);
              shouldThrow();
          } catch (TimeoutException success) {}
      }
  
  }
  