while (!isThreadBlockedOnInstanceOf(t, blocker)) {
      if (t.getState() == Thread.State.TERMINATED) {
        throw new RuntimeException("Thread " + t + " exited unexpectedly");
      }
      Thread.sleep(1);
    }
  }

  private static boolean isThreadBlockedOnInstanceOf(Thread t, Class<?> blocker) {
    return t.getState() == Thread.State.WAITING && blocker.isInstance(LockSupport.getBlocker(t));
  }

}

@AfterClass
public static void afterClass() {
    runner.close();
    runner.clean();
}
```

### Testing Best Practices

- Minimize `Thread.sleep()` - use only when absolutely necessary
- For timestamp tests: use minimal delays (50-100ms)
- Clean only test-specific indices (not `_all` unless needed)
- Use `runner.refresh()` after index operations

  @SuppressWarnings({"GoodTime-ApiWithNumericTimeUnit", "GoodTime-DecomposeToPrimitive"})
  @IgnoreJRERequirement
  static long toNanosSaturated(Duration duration) {
    // Using a try/catch seems lazy, but the catch block will rarely get invoked (except for
    // durations longer than approximately +/- 292 years).
    try {
      return duration.toNanos();
    } catch (ArithmeticException tooBig) {

 *
 * <h3>Derived steps</h3>
 *
 * A {@code ClosingFuture} step can be derived from one or more input {@code ClosingFuture} steps in
 * ways similar to {@link FluentFuture}s:
 *
 * <ul>
 *   <li>by transforming the value from a successful input step,
 *   <li>by catching the exception from a failed input step, or
 *   <li>by combining the results of several input steps.
 * </ul>
 *

            try {
                // Wait before retry (except first attempt)
                if (attempt > 0) {
                    long delay = retryDelay * (1L << attempt); // Exponential backoff
                    Thread.sleep(delay);
                    log.debug("Reconnection attempt {} for {}", attempt + 1, info.getPath());
                }

                // Perform the actual reconnection

    assertThat(server.takeRequest().exchangeIndex).isEqualTo(0)

    // Give the socket a chance to become stale.
    connection!!.idleAtNs -= IDLE_CONNECTION_HEALTHY_NS
    Thread.sleep(250)

    val requestB =
      Request(
        url = server.url("/"),
        body = "b".toRequestBody("text/plain".toMediaType()),
      )
    val responseB = client.newCall(requestB).execute()

        entry.setMaxAge(100); // 100ms

        assertFalse(entry.isExpired());
        assertFalse(entry.needsRefresh());

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            // Ignore
        }

        assertTrue(entry.isExpired());
        assertTrue(entry.needsRefresh());
    }

    @Test

    }
  }

  @Test
  fun fullCallTimeoutDoesNotApplyOnceConnected() {
    enableProtocol(Protocol.HTTP_2)
    val body =
      MockSocketHandler()
        .sendResponse("response A\n")
        .sleep(750, TimeUnit.MILLISECONDS)
        .sendResponse("response B\n")
        .receiveRequest("request C\n")
        .exhaustResponse()
        .exhaustRequest()
    server.enqueue(
      MockResponse

    this.validator = validator;
    this.errorMessage = errorMessage;
  }

  // Override hashCode() to access delegate directly (so that it doesn't trigger the validate() call
  // via delegate()); it seems inappropriate to throw ISE on this method.
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  private void validate() {

  AbstractIteratorTester(
      int steps,
      Iterable<E> elementsToInsertIterable,
      Iterable<? extends IteratorFeature> features,
      Iterable<E> expectedElements,
      KnownOrder knownOrder,
      int startIndex) {
    // periodically we should manually try (steps * 3 / 2) here; all tests but
    // one should still pass (testVerifyGetsCalled()).