}

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

      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun interruptLater(delayMillis: Int) {
    val toInterrupt = Thread.currentThread()
    val interruptingCow =
      Thread {
        sleep(delayMillis)
        toInterrupt.interrupt()
      }
    interruptingCow.start()
  }

  companion object {

    checkNotNull(t); // to satisfy NullPointerTester
    if (t instanceof InterruptedException) {
      currentThread().interrupt();
    }
  }

  static void interruptCurrentThread() {
    Thread.currentThread().interrupt();
  }

  static void rethrowIfErrorOtherThanStackOverflow(Throwable t) {
    checkNotNull(t);
    if (t instanceof Error && !(t instanceof StackOverflowError)) {

    checkNotNull(t); // to satisfy NullPointerTester
    if (t instanceof InterruptedException) {
      currentThread().interrupt();
    }
  }

  static void interruptCurrentThread() {
    Thread.currentThread().interrupt();
  }

  static void rethrowIfErrorOtherThanStackOverflow(Throwable t) {
    checkNotNull(t);
    if (t instanceof Error && !(t instanceof StackOverflowError)) {

     */
    public synchronized void stop() {
        if (thread != null) {
            thread.interrupt();
            thread = null;
            if (logger.isDebugEnabled()) {
                logger.debug("TimeoutManager stopped.");
            }
        }
    }

    /**
     * Interrupts the thread and waits for it to terminate.
     *
     * @param timeoutMillis

        // Wait a bit and update activity
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        channelInfo.updateActivity();
        assertTrue(channelInfo.getLastActivityTime() > initialTime);
        assertTrue(channelInfo.getIdleTime() >= 0);
    }

    @Test

   * @throws Exception if unable to load the result
   * @throws InterruptedException if this method is interrupted. {@code InterruptedException} is
   *     treated like any other {@code Exception} in all respects except that, when it is caught,
   *     the thread's interrupt status is set
   */
  public abstract V load(K key) throws Exception;

  /**

  @SuppressWarnings("FutureReturnValueIgnored")
  @Footprint(exclude = {Runnable.class, Executor.class, Thread.class, Exception.class})
  public Object measureSize() {
    for (Thread thread : blockedThreads) {
      thread.interrupt();
    }
    blockedThreads.clear();
    Facade<Object> f = impl.newFacade();
    for (int i = 0; i < numThreads; i++) {
      Thread thread =
          new Thread() {
            @Override

 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * {@snippet :
 * final CountDownLatch latch = new CountDownLatch(1);

 * ordinary tests.
 *
 * <p>Failure of the expected event to occur within an implementation-defined "reasonable" time
 * period or an interrupt while waiting for the expected event will result in a {@link
 * RuntimeException}.
 *
 * <p>Here's an example that tests a {@code finalize} method:
 *
 * {@snippet :
 * final CountDownLatch latch = new CountDownLatch(1);