*/
    public void setMaxAccessCount(final long maxAccessCount) {
        this.maxAccessCount = maxAccessCount;
    }

    /**
     * Sets the interval time between crawling executions.
     *
     * @param crawlingExecutionInterval The crawling execution interval in milliseconds
     */
    public void setCrawlingExecutionInterval(final long crawlingExecutionInterval) {

 * limitations under the License.
 *
 */
package mockwebserver3.internal

import okio.Buffer
import okio.Sink

/**
 * A sink that sleeps [periodDelayNanos] every [bytesPerPeriod] bytes. Unlike [okio.Throttler],
 * this permits any interval to be used.
 */
internal class ThrottledSink(
  private val socket: MockWebServerSocket,
  private val delegate: Sink,

import java.util.concurrent.TimeUnit
import okhttp3.internal.canParseAsIpAddress
import okhttp3.tls.internal.der.AlgorithmIdentifier
import okhttp3.tls.internal.der.AttributeTypeAndValue
import okhttp3.tls.internal.der.BasicConstraints
import okhttp3.tls.internal.der.BitString
import okhttp3.tls.internal.der.Certificate
import okhttp3.tls.internal.der.CertificateAdapters
import okhttp3.tls.internal.der.CertificateAdapters.generalNameDnsName

                }
            }
        }
    }

    /**
     * Sets the crawling execution interval.
     * This interval controls the delay between starting new crawler threads
     * and the frequency of status checks during crawling operations.
     *
     * @param crawlingExecutionInterval interval in milliseconds
     */
    public void setCrawlingExecutionInterval(final long crawlingExecutionInterval) {

        assertEquals(0L, webFsIndexHelper.maxAccessCount);
    }

    @Test
    public void test_setCrawlingExecutionInterval() {
        long interval = 5000L;
        webFsIndexHelper.setCrawlingExecutionInterval(interval);
        assertEquals(interval, webFsIndexHelper.crawlingExecutionInterval);
    }

    @Test
    public void test_setCrawlingExecutionInterval_withDefaultValue() {

import okhttp3.Protocol.HTTP_2
import okhttp3.internal.asFactory
import okhttp3.internal.checkDuration
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RouteDatabase
import okhttp3.internal.immutableListOf
import okhttp3.internal.platform.Platform
import okhttp3.internal.proxy.NullProxySelector
import okhttp3.internal.tls.CertificateChainCleaner

     */
    protected int documentExpires = -2;

    /**
     * Hot thread monitoring interval in seconds.
     * -1: disabled, positive value: enable hot thread monitoring with specified interval.
     * Used for performance analysis and debugging of the crawler process.
     */
    protected int hotThreadInterval = -1;

    /**

    MINIO_ROOT_USER: "minio"
    MINIO_ROOT_PASSWORD: "minio123"
    MINIO_KMS_SECRET_KEY: "my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw="
  healthcheck:
    test: ["CMD", "mc", "ready", "local"]
    interval: 5s
    timeout: 5s
    retries: 5

# starts 4 docker containers running minio server instances.
# using nginx reverse proxy, load balancing, you can access
# it through port 9000.
services:
  minio1:

    /**
     * Set the health check interval
     * @param millis the health check interval in milliseconds
     */
    public void setHealthCheckInterval(int millis) {
        if (millis <= 0) {
            throw new IllegalArgumentException("Health check interval must be positive");
        }
        this.healthCheckInterval = millis;
        log.info("Set health check interval to {} ms", millis);
    }

    /**

        points_per_minute = POINTS_PER_MINUTE_LIMIT * self.speed_multiplier
        interval = 60 / (points_per_minute / self.last_query_cost)
        time_since_last_request = (now - self.last_request_start_time).total_seconds()
        if time_since_last_request < interval:
            secondary_limit_wait_time = interval - time_since_last_request

        final_wait_time = ceil(max(primary_limit_wait_time, secondary_limit_wait_time))