{[]string{"unknown-host:65432"}, time.Duration(0), time.Duration(0), time.Duration(0), []bool{true}},                            // 4
		{[]string{"localhost:65432"}, time.Duration(0), time.Duration(0), time.Duration(0), []bool{false}},                              // 5

   * @since 28.0 (but only since 33.4.0 in the Android flavor)
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // java.time.Duration
  @ParametricNullness
  public static <V extends @Nullable Object> V getUninterruptibly(
      Future<V> future, Duration timeout) throws ExecutionException, TimeoutException {
    return getUninterruptibly(future, toNanosSaturated(timeout), TimeUnit.NANOSECONDS);
  }

  /**

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 {

   */
  @CanIgnoreReturnValue
  @J2ktIncompatible
  @GwtIncompatible // java.time.Duration
  @ParametricNullness
  @SuppressWarnings("Java7ApiChecker")
  @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 {

    assertThrows(IllegalStateException.class, () -> builder2.softValues());
    assertThrows(IllegalStateException.class, () -> builder2.weakValues());
  }

  @GwtIncompatible // Duration
  public void testLargeDurationsAreOk() {
    Duration threeHundredYears = Duration.ofDays(365 * 300);
    CacheBuilder<Object, Object> unused =
        CacheBuilder.newBuilder()
            .expireAfterWrite(threeHundredYears)

import com.google.common.annotations.J2ktIncompatible;
import com.google.errorprone.annotations.CanIgnoreReturnValue;
import com.google.errorprone.annotations.DoNotMock;
import java.time.Duration;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

		errStr = "network disconnection issues detected"
	}

	globalNetPerfRX.Reset()
	return madmin.NetperfNodeResult{Endpoint: "", TX: r.n / uint64(duration.Seconds()), RX: uint64(rx / delta.Seconds()), Error: errStr}
}

func siteNetperf(ctx context.Context, duration time.Duration) madmin.SiteNetPerfNodeResult {
	r := &netperfReader{eof: make(chan struct{})}
	r.buf = make([]byte, 128*humanize.KiByte)
	rand.Read(r.buf)

    try {
      builder.callTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.connectTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.writeTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.readTimeout(Duration.ofNanos(1))

stale_uploads_expiry            (duration)  set to expire stale multipart uploads older than this values (default: '24h')
stale_uploads_cleanup_interval  (duration)  set to change intervals when stale multipart uploads are expired (default: '6h')
delete_cleanup_interval         (duration)  set to change intervals when deleted objects are permanently deleted from ".trash" folder (default: '5m')

        val durations = JSON.parseArray(performanceTestDurationsJson.readText(StandardCharsets.UTF_8))
        val pairs = durations.flatMap { it ->
            val scenarioDurations = it as JSONObject
            val scenario = Scenario.fromTestId(scenarioDurations["scenario"] as String)
            (scenarioDurations["durations"] as JSONArray).flatMap {
                val duration = it as JSONObject