private static final long serialVersionUID = 1L;

            @Override
            public String getTimeAdjustTimeMillis() {
                return "0x1000"; // Hex notation string
            }

            @Override
            public Long getTimeAdjustTimeMillisAsLong() {
                return 4096L; // Decimal equivalent
            }
        };

  }

  @Test
  fun customDuration() {
    val now = System.currentTimeMillis()
    val heldCertificate =
      HeldCertificate
        .Builder()
        .duration(5, TimeUnit.SECONDS)
        .build()
    val certificate = heldCertificate.certificate
    val deltaMillis = 1000.0
    val durationMillis = 5000L
    assertThat(certificate.notBefore.time.toDouble())

// isServerResolvable - checks if the endpoint is resolvable
// by sending a naked HTTP request with liveness checks.
func isServerResolvable(endpoint Endpoint, timeout time.Duration) error {
	serverURL := &url.URL{
		Scheme: endpoint.Scheme,
		Host:   endpoint.Host,
		Path:   pathJoin(healthCheckPathPrefix, healthCheckLivenessPath),
	}

	httpClient := &http.Client{

	}

	// Return the collected common max time, with maxima
	return latest, maxima
}

// commonTime returns a maximally occurring time from a list of time.
func commonTimeAndOccurrence(times []time.Time, group time.Duration) (maxTime time.Time, maxima int) {
	timeOccurrenceMap := make(map[int64]int, len(times))
	groupNano := group.Nanoseconds()
	// Ignore the uuid sentinel and count the rest.
	for _, t := range times {

		select {
		case <-ctx.Done():
			return ctx.Err()
		default:
			// Sleep and stagger to avoid blocked CPU and thundering
			// herd upon start up sequence.
			time.Sleep(25*time.Millisecond + time.Duration(rand.Int63n(int64(100*time.Millisecond))))
			retries++
			// after 20 retries start logging that servers are not reachable yet
			if retries >= 20 {

	if err != nil {
		t.Fatal(err)
	}

	for {
		_, err := restClient.DiskInfo(t.Context(), DiskInfoOptions{})
		if err == nil || errors.Is(err, errUnformattedDisk) {
			break
		}
		time.Sleep(time.Duration(rand.Float64() * float64(100*time.Millisecond)))
	}

	return restClient
}

func TestStorageRESTClientDiskInfo(t *testing.T) {
	restClient := newStorageRESTHTTPServerClient(t)

    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(1))
        .build()
    executeSynchronously("/a").assertBody("abc")

    // Second request: time out after 250ms.
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val request = Request.Builder().url(server.url("/b")).build()

    for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
      char tmp = array[i];
      array[i] = array[j];
      array[j] = tmp;
    }
  }

  /**
   * Performs a right rotation of {@code array} of "distance" places, so that the first element is
   * moved to index "distance", and the element at index {@code i} ends up at index {@code (distance

    for (int i = fromIndex, j = toIndex - 1; i < j; i++, j--) {
      float tmp = array[i];
      array[i] = array[j];
      array[j] = tmp;
    }
  }

  /**
   * Performs a right rotation of {@code array} of "distance" places, so that the first element is
   * moved to index "distance", and the element at index {@code i} ends up at index {@code (distance

	public final fun callTimeout (Ljava/time/Duration;)Lokhttp3/OkHttpClient$Builder;
	public final fun callTimeout-LRDsOJo (J)Lokhttp3/OkHttpClient$Builder;
	public final fun certificatePinner (Lokhttp3/CertificatePinner;)Lokhttp3/OkHttpClient$Builder;
	public final fun connectTimeout (JLjava/util/concurrent/TimeUnit;)Lokhttp3/OkHttpClient$Builder;
	public final fun connectTimeout (Ljava/time/Duration;)Lokhttp3/OkHttpClient$Builder;