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.*;
  import java.util.concurrent.*;
  import static java.util.concurrent.TimeUnit.MILLISECONDS;
  import java.math.BigInteger;
  import java.security.*;
  
  public class AbstractExecutorServiceTest extends JSR166TestCase {
      public static void main(String[] args) {
          junit.textui.TestRunner.run (suite());
      }
      public static Test suite() {
          return new TestSuite(AbstractExecutorServiceTest.class);
      }
  
      /**
       * A no-frills implementation of AbstractExecutorService, designed
       * to test the submit methods only.
       */
      static class DirectExecutorService extends AbstractExecutorService {
          public void execute(Runnable r) { r.run(); }
          public void shutdown() { shutdown = true; }
          public List<Runnable> shutdownNow() { shutdown = true; return Collections.EMPTY_LIST; }
          public boolean isShutdown() { return shutdown; }
          public boolean isTerminated() { return isShutdown(); }
          public boolean awaitTermination(long timeout, TimeUnit unit) { return isShutdown(); }
          private volatile boolean shutdown = false;
      }
  
      /**
       * execute(runnable) runs it to completion
       */
      public void testExecuteRunnable() throws Exception {
          ExecutorService e = new DirectExecutorService();
          TrackedShortRunnable task = new TrackedShortRunnable();
          assertFalse(task.done);
          Future<?> future = e.submit(task);
          future.get();
          assertTrue(task.done);
      }
  
  
      /**
       * Completed submit(callable) returns result
       */
      public void testSubmitCallable() throws Exception {
          ExecutorService e = new DirectExecutorService();
          Future<String> future = e.submit(new StringTask());
          String result = future.get();
          assertSame(TEST_STRING, result);
      }
  
      /**
       * Completed submit(runnable) returns successfully
       */
      public void testSubmitRunnable() throws Exception {
          ExecutorService e = new DirectExecutorService();
          Future<?> future = e.submit(new NoOpRunnable());
          future.get();
          assertTrue(future.isDone());
      }
  
      /**
       * Completed submit(runnable, result) returns result
       */
      public void testSubmitRunnable2() throws Exception {
          ExecutorService e = new DirectExecutorService();
          Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING);
          String result = future.get();
          assertSame(TEST_STRING, result);
      }
  
  
      /**
       * A submitted privileged action to completion
       */
      public void testSubmitPrivilegedAction() throws Exception {
          Policy savedPolicy = null;
          try {
              savedPolicy = Policy.getPolicy();
              AdjustablePolicy policy = new AdjustablePolicy();
              policy.addPermission(new RuntimePermission("getContextClassLoader"));
              policy.addPermission(new RuntimePermission("setContextClassLoader"));
              Policy.setPolicy(policy);
          } catch (AccessControlException ok) {
              return;
          }
          try {
              ExecutorService e = new DirectExecutorService();
              Future future = e.submit(Executors.callable(new PrivilegedAction() {
                      public Object run() {
                          return TEST_STRING;
                      }}));
  
              Object result = future.get();
              assertSame(TEST_STRING, result);
          }
          finally {
              try {
                  Policy.setPolicy(savedPolicy);
              } catch (AccessControlException ok) {
                  return;
              }
          }
      }
  
      /**
       * A submitted a privileged exception action runs to completion
       */
      public void testSubmitPrivilegedExceptionAction() throws Exception {
          Policy savedPolicy = null;
          try {
              savedPolicy = Policy.getPolicy();
              AdjustablePolicy policy = new AdjustablePolicy();
              policy.addPermission(new RuntimePermission("getContextClassLoader"));
              policy.addPermission(new RuntimePermission("setContextClassLoader"));
              Policy.setPolicy(policy);
          } catch (AccessControlException ok) {
              return;
          }
  
          try {
              ExecutorService e = new DirectExecutorService();
              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                      public Object run() {
                          return TEST_STRING;
                      }}));
  
              Object result = future.get();
              assertSame(TEST_STRING, result);
          }
          finally {
              Policy.setPolicy(savedPolicy);
          }
      }
  
      /**
       * A submitted failed privileged exception action reports exception
       */
      public void testSubmitFailedPrivilegedExceptionAction() throws Exception {
          Policy savedPolicy = null;
          try {
              savedPolicy = Policy.getPolicy();
              AdjustablePolicy policy = new AdjustablePolicy();
              policy.addPermission(new RuntimePermission("getContextClassLoader"));
              policy.addPermission(new RuntimePermission("setContextClassLoader"));
              Policy.setPolicy(policy);
          } catch (AccessControlException ok) {
              return;
          }
  
          try {
              ExecutorService e = new DirectExecutorService();
              Future future = e.submit(Executors.callable(new PrivilegedExceptionAction() {
                      public Object run() throws Exception {
                          throw new IndexOutOfBoundsException();
                      }}));
  
              future.get();
              shouldThrow();
          } catch (ExecutionException success) {
              assertTrue(success.getCause() instanceof IndexOutOfBoundsException);
          }
          finally {
              Policy.setPolicy(savedPolicy);
          }
      }
  
      /**
       * execute(null runnable) throws NPE
       */
      public void testExecuteNullRunnable() {
          try {
              ExecutorService e = new DirectExecutorService();
              e.submit((Runnable) null);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
  
      /**
       * submit(null callable) throws NPE
       */
      public void testSubmitNullCallable() {
          try {
              ExecutorService e = new DirectExecutorService();
              e.submit((Callable) null);
              shouldThrow();
          } catch (NullPointerException success) {}
      }
  
      /**
       * submit(runnable) throws RejectedExecutionException if
       * executor is saturated.
       */
      public void testExecute1() {
          ThreadPoolExecutor p =
              new ThreadPoolExecutor(1, 1,
                                     60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(1));
          try {
              for (int i = 0; i < 2; ++i)
                  p.submit(new MediumRunnable());
              for (int i = 0; i < 2; ++i) {
                  try {
                      p.submit(new MediumRunnable());
                      shouldThrow();
                  } catch (RejectedExecutionException success) {}
              }
          } finally {
              joinPool(p);
          }
      }
  
      /**
       * submit(callable) throws RejectedExecutionException
       * if executor is saturated.
       */
      public void testExecute2() {
          ThreadPoolExecutor p =
              new ThreadPoolExecutor(1, 1,
                                     60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(1));
          try {
              for (int i = 0; i < 2; ++i)
                  p.submit(new MediumRunnable());
              for (int i = 0; i < 2; ++i) {
                  try {
                      p.submit(new SmallCallable());
                      shouldThrow();
                  } catch (RejectedExecutionException success) {}
              }
          } finally {
              joinPool(p);
          }
      }
  
  
      /**
       *  Blocking on submit(callable) throws InterruptedException if
       *  caller interrupted.
       */
      public void testInterruptedSubmit() throws InterruptedException {
          final ThreadPoolExecutor p = new ThreadPoolExecutor(1,1,60, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
          Thread t = new Thread(new CheckedInterruptedRunnable() {
              public void realRun() throws Exception {
                  p.submit(new CheckedCallable<Object>() {
                               public Object realCall()
                                   throws InterruptedException {
                                   Thread.sleep(SMALL_DELAY_MS);
                                   return null;
                               }}).get();
              }});
  
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          t.interrupt();
          joinPool(p);
      }
  
      /**
       *  get of submitted callable throws InterruptedException if callable
       *  interrupted
       */
      public void testSubmitIE() throws InterruptedException {
          final ThreadPoolExecutor p =
              new ThreadPoolExecutor(1, 1,
                                     60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(10));
  
          Thread t = new Thread(new CheckedInterruptedRunnable() {
              public void realRun() throws Exception {
                  p.submit(new SmallCallable()).get();
              }});
  
          t.start();
          Thread.sleep(SHORT_DELAY_MS);
          t.interrupt();
          t.join();
          joinPool(p);
      }
  
      /**
       *  get of submit(callable) throws ExecutionException if callable
       *  throws exception
       */
      public void testSubmitEE() throws InterruptedException {
          ThreadPoolExecutor p =
              new ThreadPoolExecutor(1, 1,
                                     60, TimeUnit.SECONDS,
                                     new ArrayBlockingQueue<Runnable>(10));
  
          Callable c = new Callable() {
              public Object call() { return 5/0; }};
  
          try {
              p.submit(c).get();
              shouldThrow();
          } catch (ExecutionException success) {
              assertTrue(success.getCause() instanceof ArithmeticException);
          }
          joinPool(p);
      }
  
      /**
       * invokeAny(null) throws NPE
       */
      public void testInvokeAny1()
          throws InterruptedException, ExecutionException {
          ExecutorService e = new DirectExecutorService();
          try {
              e.invokeAny(null);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAny(empty collection) throws IAE
       */
      public void testInvokeAny2()
          throws InterruptedException, ExecutionException {
          ExecutorService e = new DirectExecutorService();
          try {
              e.invokeAny(new ArrayList<Callable<String>>());
              shouldThrow();
          } catch (IllegalArgumentException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAny(c) throws NPE if c has null elements
       */
      public void testInvokeAny3() throws Exception {
          ExecutorService e = new DirectExecutorService();
          List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
          l.add(new Callable<Integer>() {
                    public Integer call() { return 5/0; }});
          l.add(null);
          try {
              e.invokeAny(l);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAny(c) throws ExecutionException if no task in c completes
       */
      public void testInvokeAny4() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          List<Callable<String>> l = new ArrayList<Callable<String>>();
          l.add(new NPETask());
          try {
              e.invokeAny(l);
              shouldThrow();
          } catch (ExecutionException success) {
              assertTrue(success.getCause() instanceof NullPointerException);
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAny(c) returns result of some task in c if at least one completes
       */
      public void testInvokeAny5() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new StringTask());
              l.add(new StringTask());
              String result = e.invokeAny(l);
              assertSame(TEST_STRING, result);
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAll(null) throws NPE
       */
      public void testInvokeAll1() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          try {
              e.invokeAll(null);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAll(empty collection) returns empty collection
       */
      public void testInvokeAll2() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>());
              assertTrue(r.isEmpty());
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAll(c) throws NPE if c has null elements
       */
      public void testInvokeAll3() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          List<Callable<String>> l = new ArrayList<Callable<String>>();
          l.add(new StringTask());
          l.add(null);
          try {
              e.invokeAll(l);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * get of returned element of invokeAll(c) throws exception on failed task
       */
      public void testInvokeAll4() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new NPETask());
              List<Future<String>> futures = e.invokeAll(l);
              assertEquals(1, futures.size());
              try {
                  futures.get(0).get();
                  shouldThrow();
              } catch (ExecutionException success) {
                  assertTrue(success.getCause() instanceof NullPointerException);
              }
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * invokeAll(c) returns results of all completed tasks in c
       */
      public void testInvokeAll5() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new StringTask());
              l.add(new StringTask());
              List<Future<String>> futures = e.invokeAll(l);
              assertEquals(2, futures.size());
              for (Future<String> future : futures)
                  assertSame(TEST_STRING, future.get());
          } finally {
              joinPool(e);
          }
      }
  
  
      /**
       * timed invokeAny(null) throws NPE
       */
      public void testTimedInvokeAny1() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAny(null time unit) throws NPE
       */
      public void testTimedInvokeAnyNullTimeUnit() throws Exception {
          ExecutorService e = new DirectExecutorService();
          List<Callable<String>> l = new ArrayList<Callable<String>>();
          l.add(new StringTask());
          try {
              e.invokeAny(l, MEDIUM_DELAY_MS, null);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAny(empty collection) throws IAE
       */
      public void testTimedInvokeAny2() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (IllegalArgumentException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAny(c) throws NPE if c has null elements
       */
      public void testTimedInvokeAny3() throws Exception {
          ExecutorService e = new DirectExecutorService();
          List<Callable<Integer>> l = new ArrayList<Callable<Integer>>();
          l.add(new Callable<Integer>() {
                    public Integer call() { return 5/0; }});
          l.add(null);
          try {
              e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAny(c) throws ExecutionException if no task completes
       */
      public void testTimedInvokeAny4() throws Exception {
          ExecutorService e = new DirectExecutorService();
          List<Callable<String>> l = new ArrayList<Callable<String>>();
          l.add(new NPETask());
          try {
              e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (ExecutionException success) {
              assertTrue(success.getCause() instanceof NullPointerException);
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAny(c) returns result of some task in c
       */
      public void testTimedInvokeAny5() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new StringTask());
              l.add(new StringTask());
              String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
              assertSame(TEST_STRING, result);
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAll(null) throws NPE
       */
      public void testTimedInvokeAll1() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          try {
              e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAll(null time unit) throws NPE
       */
      public void testTimedInvokeAllNullTimeUnit() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          List<Callable<String>> l = new ArrayList<Callable<String>>();
          l.add(new StringTask());
          try {
              e.invokeAll(l, MEDIUM_DELAY_MS, null);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAll(empty collection) returns empty collection
       */
      public void testTimedInvokeAll2() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, MILLISECONDS);
              assertTrue(r.isEmpty());
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAll(c) throws NPE if c has null elements
       */
      public void testTimedInvokeAll3() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          List<Callable<String>> l = new ArrayList<Callable<String>>();
          l.add(new StringTask());
          l.add(null);
          try {
              e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
              shouldThrow();
          } catch (NullPointerException success) {
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * get of returned element of invokeAll(c) throws exception on failed task
       */
      public void testTimedInvokeAll4() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new NPETask());
              List<Future<String>> futures =
                  e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
              assertEquals(1, futures.size());
              try {
                  futures.get(0).get();
                  shouldThrow();
              } catch (ExecutionException success) {
                  assertTrue(success.getCause() instanceof NullPointerException);
              }
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAll(c) returns results of all completed tasks in c
       */
      public void testTimedInvokeAll5() throws Exception {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new StringTask());
              l.add(new StringTask());
              List<Future<String>> futures =
                  e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
              assertEquals(2, futures.size());
              for (Future<String> future : futures)
                  assertSame(TEST_STRING, future.get());
          } finally {
              joinPool(e);
          }
      }
  
      /**
       * timed invokeAll cancels tasks not completed by timeout
       */
      public void testTimedInvokeAll6() throws InterruptedException {
          ExecutorService e = new DirectExecutorService();
          try {
              List<Callable<String>> l = new ArrayList<Callable<String>>();
              l.add(new StringTask());
              l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING));
              l.add(new StringTask());
              List<Future<String>> futures =
                  e.invokeAll(l, SMALL_DELAY_MS, MILLISECONDS);
              assertEquals(3, futures.size());
              Iterator<Future<String>> it = futures.iterator();
              Future<String> f1 = it.next();
              Future<String> f2 = it.next();
              Future<String> f3 = it.next();
              assertTrue(f1.isDone());
              assertFalse(f1.isCancelled());
              assertTrue(f2.isDone());
              assertTrue(f3.isDone());
              assertTrue(f3.isCancelled());
          } finally {
              joinPool(e);
          }
      }
  
  }
  