return;
            }
          }
          // Remove the interrupt bit before each task. The interrupt is for the "current task" when
          // it is sent, so subsequent tasks in the queue should not be caused to be interrupted
          // by a previous one in the queue being interrupted.
          interruptedDuringTask |= Thread.interrupted();
          try {
            task.run();

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

  class Interruptenator extends Thread {
    final AtomicBoolean shutdown;

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

                crawlerThreadGroup.interrupt();
                if (logger.isDebugEnabled()) {
                    logger.debug("Interrupted all crawler threads: sessionId={}, activeCount={}", crawlerContext.sessionId,
                            crawlerThreadGroup.activeCount());
                }
            }
        } catch (final Exception e) {

                    task.run();
                }
            }
        } catch (final InterruptedException e) {
            logger.warn("Interrupted generating thumbnail: id={}, command={}", thumbnailId, cmdList, e);
            Thread.currentThread().interrupt();
        } catch (final Exception e) {
            logger.warn("Failed to generate thumbnail: id={}, command={}", thumbnailId, cmdList, e);
        } finally {

    // 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() {

          TimeoutsToUse.PAST,
          // prefer responding to interrupt over timing out
          isInterruptible(method) ? Outcome.INTERRUPT : Outcome.FAILURE);
      addTests(
          suite,
          method,
          Scenario.UNSATISFIED_AND_INTERRUPTED_BEFORE_WAITING,
          TimeoutsToUse.SMALL,
          isInterruptible(method) ? Outcome.INTERRUPT : Outcome.FAILURE);
      addTests(
          suite,

        } catch (e: IOException) {
          readFailure = e
          return
        }
      }
    } finally {
      if (interrupted) {
        Thread.currentThread().interrupt() // Retain interrupted status.
      }
    }
  }

    // 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() {

                    long threadEnd = System.nanoTime();
                    totalTime.addAndGet(threadEnd - threadStart);

                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    endLatch.countDown();
                }
            });
        }

        startLatch.countDown(); // Start all threads

  }

  @J2ktIncompatible
  @GwtIncompatible // Thread.interrupt
  public void testGetUnchecked_interrupted() {
    Thread.currentThread().interrupt();
    try {
      assertEquals("foo", getUnchecked(immediateFuture("foo")));
      assertTrue(Thread.currentThread().isInterrupted());
    } finally {
      Thread.interrupted();
    }
  }

  public void testGetUnchecked_cancelled() {