// Test that interrupts result in RuntimeException, not InterruptedException.
  // Trickier than it looks, because runFinalization swallows interrupts.
  // ----------------------------------------------------------------

  class Interruptenator extends Thread {
    final AtomicBoolean shutdown;

    Interruptenator(final Thread interruptee) {
      this(interruptee, new AtomicBoolean(false));
    }

  public static void awaitUninterruptibly(CountDownLatch latch) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          latch.await();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  /**

     * the interrupting thread doesn't interrupt the _next_ thing to run on this thread.
     *
     * Note: We don't reset the interrupted bit, just wait for it to be set. If this is a thread
     * pool thread, the thread pool will reset it for us. Otherwise, the interrupted bit may have
     * been intended for something else, so don't clear it.
     */
    boolean restoreInterruptedBit = false;
    int spinCount = 0;

  /** Runnable which will interrupt the target thread repeatedly when run. */
  private static final class Interruptenator implements Runnable {
    private final long everyMillis;
    private final Thread interruptee;
    private volatile boolean shouldStop = false;

    Interruptenator(Thread interruptee, long everyMillis) {
      this.everyMillis = everyMillis;
      this.interruptee = interruptee;
    }

    @Override

    // Run a task on the composed Executor that interrupts its thread (i.e. this thread).
    fakePool.execute(
        new Runnable() {
          @Override
          public void run() {
            Thread.currentThread().interrupt();
          }
        });
    // Run a task that expects that it is not interrupted while it is running.
    e.execute(
        new Runnable() {

  /** Runnable which will interrupt the target thread repeatedly when run. */
  private static final class Interruptenator implements Runnable {
    private final long everyMillis;
    private final Thread interruptee;
    private volatile boolean shouldStop = false;

    Interruptenator(Thread interruptee, long everyMillis) {
      this.everyMillis = everyMillis;
      this.interruptee = interruptee;
    }

    @Override

     * the interrupting thread doesn't interrupt the _next_ thing to run on this thread.
     *
     * Note: We don't reset the interrupted bit, just wait for it to be set. If this is a thread
     * pool thread, the thread pool will reset it for us. Otherwise, the interrupted bit may have
     * been intended for something else, so don't clear it.
     */
    boolean restoreInterruptedBit = false;
    int spinCount = 0;

  public static void awaitUninterruptibly(CountDownLatch latch) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          latch.await();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt();
      }
    }
  }

  /**

      }

      /** Checks if the state is {@link #CANCELLED} or {@link #INTERRUPTED}. */
      boolean isCancelled() {
        return (getState() & (CANCELLED | INTERRUPTED)) != 0;
      }

      /** Checks if the state is {@link #INTERRUPTED}. */
      boolean wasInterrupted() {
        return getState() == INTERRUPTED;
      }

          E e; // written exactly once, by a successful (uninterrupted) invocation of #poll
          while (true) {
            try {
              e = q.poll(deadline - System.nanoTime(), NANOSECONDS);
              break;
            } catch (InterruptedException ex) {
              interrupted = true; // note interruption and retry
            }
          }
          if (e == null) {