test/java/util/concurrent/ThreadPoolExecutor/ThrowingTasks.java

*** 33,43 ****
  import java.util.*;
  import java.util.concurrent.*;
  import java.util.concurrent.atomic.*;
  
  public class ThrowingTasks {
!     final static Random rnd = new Random();
  
      @SuppressWarnings("serial")
      static class UncaughtExceptions
          extends ConcurrentHashMap<Class<?>, Integer> {
  
--- 33,43 ----
  import java.util.*;
  import java.util.concurrent.*;
  import java.util.concurrent.atomic.*;
  
  public class ThrowingTasks {
!     static final Random rnd = new Random();
  
      @SuppressWarnings("serial")
      static class UncaughtExceptions
          extends ConcurrentHashMap<Class<?>, Integer> {
  
*** 63,119 ****
              Integer i = get(key);
              put(key, (i == null) ? 1 : i + 1);
          }
      }
  
!     final static UncaughtExceptions uncaughtExceptions
          = new UncaughtExceptions();
!     final static UncaughtExceptionsTable uncaughtExceptionsTable
          = new UncaughtExceptionsTable();
!     final static AtomicLong totalUncaughtExceptions
          = new AtomicLong(0);
!     final static CountDownLatch uncaughtExceptionsLatch
          = new CountDownLatch(24);
  
!     final static Thread.UncaughtExceptionHandler handler
          = new Thread.UncaughtExceptionHandler() {
                  public void uncaughtException(Thread t, Throwable e) {
                      check(! Thread.currentThread().isInterrupted());
                      totalUncaughtExceptions.getAndIncrement();
                      uncaughtExceptions.inc(e.getClass());
                      uncaughtExceptionsTable.inc(e.getClass());
                      uncaughtExceptionsLatch.countDown();
                  }};
  
!     final static ThreadGroup tg = new ThreadGroup("Flaky");
  
!     final static ThreadFactory tf = new ThreadFactory() {
              public Thread newThread(Runnable r) {
                  Thread t = new Thread(tg, r);
                  t.setUncaughtExceptionHandler(handler);
                  return t;
              }};
  
!     final static RuntimeException rte = new RuntimeException();
!     final static Error error = new Error();
!     final static Throwable weird = new Throwable();
!     final static Exception checkedException = new Exception();
  
      static class Thrower implements Runnable {
          Throwable t;
          Thrower(Throwable t) { this.t = t; }
          @SuppressWarnings("deprecation")
          public void run() { if (t != null) Thread.currentThread().stop(t); }
      }
  
!     final static Thrower noThrower      = new Thrower(null);
!     final static Thrower rteThrower     = new Thrower(rte);
!     final static Thrower errorThrower   = new Thrower(error);
!     final static Thrower weirdThrower   = new Thrower(weird);
!     final static Thrower checkedThrower = new Thrower(checkedException);
  
!     final static List<Thrower> throwers = Arrays.asList(
          noThrower, rteThrower, errorThrower, weirdThrower, checkedThrower);
  
      static class Flaky implements Runnable {
          final Runnable beforeExecute;
          final Runnable execute;
--- 63,119 ----
              Integer i = get(key);
              put(key, (i == null) ? 1 : i + 1);
          }
      }
  
!     static final UncaughtExceptions uncaughtExceptions
          = new UncaughtExceptions();
!     static final UncaughtExceptionsTable uncaughtExceptionsTable
          = new UncaughtExceptionsTable();
!     static final AtomicLong totalUncaughtExceptions
          = new AtomicLong(0);
!     static final CountDownLatch uncaughtExceptionsLatch
          = new CountDownLatch(24);
  
!     static final Thread.UncaughtExceptionHandler handler
          = new Thread.UncaughtExceptionHandler() {
                  public void uncaughtException(Thread t, Throwable e) {
                      check(! Thread.currentThread().isInterrupted());
                      totalUncaughtExceptions.getAndIncrement();
                      uncaughtExceptions.inc(e.getClass());
                      uncaughtExceptionsTable.inc(e.getClass());
                      uncaughtExceptionsLatch.countDown();
                  }};
  
!     static final ThreadGroup tg = new ThreadGroup("Flaky");
  
!     static final ThreadFactory tf = new ThreadFactory() {
              public Thread newThread(Runnable r) {
                  Thread t = new Thread(tg, r);
                  t.setUncaughtExceptionHandler(handler);
                  return t;
              }};
  
!     static final RuntimeException rte = new RuntimeException();
!     static final Error error = new Error();
!     static final Throwable weird = new Throwable();
!     static final Exception checkedException = new Exception();
  
      static class Thrower implements Runnable {
          Throwable t;
          Thrower(Throwable t) { this.t = t; }
          @SuppressWarnings("deprecation")
          public void run() { if (t != null) Thread.currentThread().stop(t); }
      }
  
!     static final Thrower noThrower      = new Thrower(null);
!     static final Thrower rteThrower     = new Thrower(rte);
!     static final Thrower errorThrower   = new Thrower(error);
!     static final Thrower weirdThrower   = new Thrower(weird);
!     static final Thrower checkedThrower = new Thrower(checkedException);
  
!     static final List<Thrower> throwers = Arrays.asList(
          noThrower, rteThrower, errorThrower, weirdThrower, checkedThrower);
  
      static class Flaky implements Runnable {
          final Runnable beforeExecute;
          final Runnable execute;