FUTURE(Timeout.SMALL, Timeout.MAX),
    SMALL(Timeout.SMALL),
    FINITE(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO, Timeout.SMALL),
    INFINITE(Timeout.LARGE, Timeout.MAX);

    final ImmutableList<Timeout> timeouts;

    TimeoutsToUse(Timeout... timeouts) {
      this.timeouts = ImmutableList.copyOf(timeouts);
    }
  }

  /** Possible outcomes of calling any of the methods under test. */

   * uninterruptibly.
   */
  @J2ktIncompatible
  @GwtIncompatible // concurrency
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration
  public static boolean awaitUninterruptibly(CountDownLatch latch, long timeout, TimeUnit unit) {
    boolean interrupted = false;
    try {
      long remainingNanos = unit.toNanos(timeout);

     * Sets the index timeout.
     * @param timeout The index timeout.
     */
    public void setIndexTimeout(final String timeout) {
        this.indexTimeout = timeout;
    }

    /**
     * Gets the bulk timeout.
     * @return The bulk timeout.
     */
    public String getBulkTimeout() {
        return bulkTimeout;
    }

    /**
     * Sets the bulk timeout.
     * @param timeout The bulk timeout.
     */

 * attempting to read with a short timeout. If the fails immediately we know the socket is
 * unhealthy.
 *
 * @param source the source used to read bytes from the socket.
 */
internal fun Socket.isHealthy(source: BufferedSource): Boolean =
  try {
    val readTimeout = soTimeout
    try {
      soTimeout = 1
      !source.exhausted()
    } finally {
      soTimeout = readTimeout
    }

        this.maxConnectionsPerRoute = maxConnectionsPerRoute;
    }

    /**
     * Sets the socket timeout in milliseconds.
     *
     * @param soTimeout The socket timeout
     */
    public void setSoTimeout(final Integer soTimeout) {
        this.soTimeout = soTimeout;
    }

    /**
     * Sets the cookie specification to use.
     *

        this.maxConnectionsPerRoute = maxConnectionsPerRoute;
    }

    /**
     * Sets the socket timeout in milliseconds.
     *
     * @param soTimeout The socket timeout
     */
    public void setSoTimeout(final Integer soTimeout) {
        this.soTimeout = soTimeout;
    }

    /**
     * Sets the cookie specification to use.
     *

    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {
    check(exchange == null) { "Timeouts can't be adjusted in a network interceptor" }

    return copy(readTimeoutMillis = checkDuration("readTimeout", timeout.toLong(), unit))
  }

  override fun writeTimeoutMillis(): Int = writeTimeoutMillis

  override fun withWriteTimeout(
    timeout: Int,
    unit: TimeUnit,
  ): Interceptor.Chain {

  }

  /**
   * Sets the delegate of `timeout` to [Timeout.NONE] and resets its underlying timeout
   * to the default configuration. Use this to avoid unexpected sharing of timeouts between pooled
   * connections.
   */
  private fun detachTimeout(timeout: ForwardingTimeout) {
    val oldDelegate = timeout.delegate
    timeout.setDelegate(Timeout.NONE)
    oldDelegate.clearDeadline()

 */
public abstract class HcHttpClient extends AbstractCrawlerClient {

    /** Property name for connection timeout setting */
    public static final String CONNECTION_TIMEOUT_PROPERTY = "connectionTimeout";

    /** Property name for socket timeout setting */
    public static final String SO_TIMEOUT_PROPERTY = "soTimeout";

    /** Property name for proxy host setting */
    public static final String PROXY_HOST_PROPERTY = "proxyHost";

      }

      OverrideParam.ConnectTimeout -> {
        client =
          client
            .newBuilder()
            .socketFactory(
              DelayingSocketFactory(onConnect = { timeout ->
                if (timeout == 10) {
                  throw IOException()
                }
              }),
            ).build()

        overrideBadImplementation(override = override.override, testItFails = testItFails)