timeout       int64
	minimum       int64
	entries       int64
	log           [dynamicTimeoutLogSize]time.Duration
	mutex         sync.Mutex
	retryInterval time.Duration
}

type dynamicTimeoutOpts struct {
	timeout       time.Duration
	minimum       time.Duration
	retryInterval time.Duration
}

func newDynamicTimeoutWithOpts(opts dynamicTimeoutOpts) *dynamicTimeout {

  }

  static class DurationSpec {
    private final long duration;
    private final TimeUnit unit;

    private DurationSpec(long duration, TimeUnit unit) {
      this.duration = duration;
      this.unit = unit;
    }

    public static DurationSpec of(long duration, TimeUnit unit) {
      return new DurationSpec(duration, unit);
    }

    @Override
    public int hashCode() {

   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // java.time.Duration
  @ParametricNullness
  @IgnoreJRERequirement // Users will use this only if they're already using Duration.
  public static <V extends @Nullable Object> V getUninterruptibly(
      Future<V> future, Duration timeout) throws ExecutionException, TimeoutException {

      Supplier<T> delegate, Duration duration) {
    checkNotNull(delegate);
    // The alternative of `duration.compareTo(Duration.ZERO) > 0` causes J2ObjC trouble.
    checkArgument(
        !duration.isNegative() && !duration.isZero(), "duration (%s) must be > 0", duration);
    return new ExpiringMemoizingSupplier<>(delegate, toNanosSaturated(duration));
  }

  @VisibleForTesting

  @SuppressWarnings("GoodTime") // Duration decomposition
  @IgnoreJRERequirement // No more dangerous than wherever the caller got the Duration from
  private 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();

      Supplier<T> delegate, Duration duration) {
    checkNotNull(delegate);
    // The alternative of `duration.compareTo(Duration.ZERO) > 0` causes J2ObjC trouble.
    checkArgument(
        !duration.isNegative() && !duration.isZero(), "duration (%s) must be > 0", duration);
    return new ExpiringMemoizingSupplier<>(delegate, toNanosSaturated(duration));
  }

  @VisibleForTesting

internal fun checkDuration(
  name: String,
  duration: Long,
  unit: TimeUnit,
): Int {
  check(duration >= 0L) { "$name < 0" }
  val millis = unit.toMillis(duration)
  require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

internal fun checkDuration(
  name: String,
  duration: Duration,
): Int {

        val durations: List<Map<String, Any>> = objectMapper.readValue(performanceTestDurationsJson)
        val pairs =
            durations.flatMap { scenarioDurations ->
                val scenario = Scenario.fromTestId(scenarioDurations["scenario"] as String)
                (scenarioDurations["durations"] as List<Map<String, Any>>).flatMap { duration ->

  }

  @GwtIncompatible // java.time.Duration
  public void testAdvance() {
    FakeTicker ticker = new FakeTicker();
    assertEquals(0, ticker.read());
    assertSame(ticker, ticker.advance(10));
    assertEquals(10, ticker.read());
    ticker.advance(1, MILLISECONDS);
    assertEquals(1000010L, ticker.read());
    ticker.advance(Duration.ofMillis(1));
    assertEquals(2000010L, ticker.read());
  }

	const successTimeout = 20 * time.Second

	for range dynamicTimeoutLogSize {
		rnd := f()
		duration := max(time.Duration(float64(successTimeout)*rnd), 100*time.Millisecond)
		if duration >= time.Minute {
			timeout.LogFailure()
		} else {
			timeout.LogSuccess(duration)
		}
	}
}

func TestDynamicTimeoutAdjustExponential(t *testing.T) {