/**
     * Maximum number of URLs to access during crawling.
     */
    protected long maxAccessCount = Long.MAX_VALUE;

    /**
     * Interval time in milliseconds between crawling executions.
     */
    protected long crawlingExecutionInterval = Constants.DEFAULT_CRAWLING_EXECUTION_INTERVAL;

    /**
     * Thread priority for index updater operations.
     */

   *
   * <pre>
   *   TimeLimiter limiter = . . .;
   *   TargetType proxy = limiter.newProxy(
   *       target, TargetType.class, 50, TimeUnit.MILLISECONDS);
   *   try {
   *     return proxy.someMethod();
   *   } catch (UncheckedTimeoutException e) {
   *     return DEFAULT_VALUE;
   *   }
   * </pre>
   *
   * @param target the object to proxy

| `minio_cluster_iam_last_sync_duration_millis`                   | Last successful IAM data sync duration in milliseconds. <br><br>Type: counter                                                                   |        |

	m.writesKBPerSec = float64(ioStats.WriteSectors) * float64(sectorSize) / kib / durationSecs
	if ioStats.WriteIOs > 0 {
		m.writesAwait = float64(ioStats.WriteTicks) / float64(ioStats.WriteIOs)
	}

	// TotalTicks is in milliseconds
	m.percUtil = float64(ioStats.TotalTicks) * 100 / (durationSecs * 1000)

	return
}

func newDriveMetricsCache() *cachevalue.Cache[storageMetrics] {
	var (

  }

  @Test
  @Throws(Exception::class)
  fun callTimeoutAppliesToSetup() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .headersDelay(500, TimeUnit.MILLISECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ZERO)
        .writeTimeout(Duration.ZERO)
        .callTimeout(Duration.ofMillis(100))

        addCreateContext(new jcifs.internal.smb2.persistent.DurableHandleRequest());
    }

    /**
     * Add a durable handle V2 context to this request
     * @param timeoutMs the timeout in milliseconds (0 for persistent handles)
     * @param persistent true if this should be a persistent handle
     * @return the create GUID for this handle
     */

            .build()

        // Copy to customize OkHttp for this request.
        val client1 = client.newBuilder()
            .readTimeout(500, TimeUnit.MILLISECONDS)
            .build()
        try {
          client1.newCall(request).execute().use { response ->
            println("Response 1 succeeded: $response")
          }
        } catch (e: IOException) {

        }
    }

    // Test with very large time adjustment values
    public void test_largeTimeAdjustmentValues() {
        // Test with milliseconds in a year
        long yearInMillis = 365L * 24L * 60L * 60L * 1000L;

        FessConfig yearConfig = new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

    }

    /**
     * Request a new durable handle
     * @param path the file path
     * @param type the handle type
     * @param timeout the timeout in milliseconds
     * @param leaseKey the associated lease key (can be null)
     * @return the handle GUID
     */
    public HandleGuid requestDurableHandle(String path, HandleType type, long timeout, Smb2LeaseKey leaseKey) {

    public long getDocumentSize() {
        return documentSize.get();
    }

    /**
     * Returns the total execution time for all operations.
     *
     * @return the total execution time in milliseconds
     */
    @Override
    public long getExecuteTime() {
        return executeTime;
    }