lastTimestampNs = result.timestampNs

    if (eventClass != null) {
      assertThat(result).isInstanceOf(eventClass)
    }

    if (elapsedMs != -1L) {
      assertThat(
        TimeUnit.NANOSECONDS
          .toMillis(actualElapsedNs)
          .toDouble(),
      ).isCloseTo(elapsedMs.toDouble(), 100.0)
    }

    return result
  }

  fun recordedEventTypes() = eventSequence.map { it.name }

   */
  @IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public void awaitHealthy(Duration timeout) throws TimeoutException {
    awaitHealthy(toNanosSaturated(timeout), TimeUnit.NANOSECONDS);
  }

  /**
   * Waits for the {@link ServiceManager} to become {@linkplain #isHealthy() healthy} for no more
   * than the given time. The manager will become healthy after all the component services have

      // a test timeout failure.
      val waitTime = (entryTime + 1_000_000_000L - System.nanoTime())
      if (!queue.idleLatch().await(waitTime, TimeUnit.NANOSECONDS)) {
        TaskRunner.INSTANCE.withLock {
          TaskRunner.INSTANCE.cancelAll()
        }
        fail<Unit>("Queue still active after 1000 ms")
      }
    }
  }

     */
    public static final int TIME_1904_SEC_32LE = 4;

    /**
     * Time encoding type: 1601 epoch, 64-bit nanoseconds, little-endian.
     */
    public static final int TIME_1601_NANOS_64LE = 5;

    /**
     * Time encoding type: 1601 epoch, 64-bit nanoseconds, big-endian.
     */
    public static final int TIME_1601_NANOS_64BE = 6;

    /**

            try {
                T result = operation.get();
                long responseTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
                onSuccess(responseTime);
                return result;
            } catch (Exception e) {
                long responseTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
                onFailure(e, responseTime);

  /**
   * Performs maintenance on this pool, evicting the connection that has been idle the longest if
   * either it has exceeded the keep alive limit or the idle connections limit.
   *
   * Returns the duration in nanoseconds to sleep until the next scheduled call to this method.
   * Returns -1 if no further cleanups are required.
   */
  fun closeConnections(now: Long): Long {

     *
     * @param responseKeyNT the NT response key
     * @param serverChallenge the server challenge bytes
     * @param clientChallenge the client challenge bytes
     * @param nanos1601 the timestamp in nanoseconds since 1601
     * @param avPairs the AV pairs from the Type 2 message
     * @return the calculated response
     */

      AsyncCallable<O> callable, Duration delay, ScheduledExecutorService executorService) {
    return scheduleAsync(callable, toNanosSaturated(delay), TimeUnit.NANOSECONDS, executorService);
  }

  /**
   * Schedules {@code callable} on the specified {@code executor}, returning a {@code Future}.
   *

    assertFailsWith<InterruptedIOException> {
      stream.takeHeaders()
    }
    val elapsedNanos = System.nanoTime() - startNanos
    awaitWatchdogIdle()
    // 200ms delta
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedNanos).toDouble())
      .isCloseTo(500.0, 200.0)
    assertThat(connection.openStreamCount()).isEqualTo(0)

    // Verify the peer received what was expected.

      assertThat(expected.message).isEqualTo(
        "stream was reset: PROTOCOL_ERROR",
      )
    }
    val elapsedUntilFailure = System.nanoTime() - executeAtNanos
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedUntilFailure).toDouble())
      .isCloseTo(1000.0, 250.0)

    // Confirm a single ping was sent but not acknowledged.
    val logs = testLogHandler.takeAll()