}
                // org.eclipse.aether.ConfigurationProperties.CONNECT_TIMEOUT => int
                if (connectTimeout != null) {
                    configProps.put(ConfigurationProperties.CONNECT_TIMEOUT + "." + server.getId(), connectTimeout);
                }
                // org.eclipse.aether.ConfigurationProperties.REQUEST_TIMEOUT => int

     */
    public int getConnectTimeout() {
        return connectTimeout;
    }

    /**
     * Sets the connection timeout in milliseconds.
     *
     * @param connectTimeout The connection timeout
     */
    public void setConnectTimeout(final int connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    /**
     * Gets the data timeout in milliseconds.

import okhttp3.Response;

public final class ConfigureTimeouts {
  private final OkHttpClient client;

  public ConfigureTimeouts() throws Exception {
    client = new OkHttpClient.Builder()
        .connectTimeout(5, TimeUnit.SECONDS)
        .writeTimeout(5, TimeUnit.SECONDS)
        .readTimeout(5, TimeUnit.SECONDS)
        .callTimeout(10, TimeUnit.SECONDS)
        .build();
  }

  public void run() throws Exception {

import java.util.concurrent.TimeUnit
import okhttp3.OkHttpClient
import okhttp3.Request

class ConfigureTimeouts {
  private val client: OkHttpClient =
    OkHttpClient
      .Builder()
      .connectTimeout(5, TimeUnit.SECONDS)
      .writeTimeout(5, TimeUnit.SECONDS)
      .readTimeout(5, TimeUnit.SECONDS)
      .callTimeout(10, TimeUnit.SECONDS)
      .build()

  fun run() {
    val request =
      Request

      listOf()
    }
  }

  @Throws(IOException::class)
  open fun connectSocket(
    socket: Socket,
    address: InetSocketAddress,
    connectTimeout: Int,
  ) {
    socket.connect(address, connectTimeout)
  }

  open fun log(
    message: String,
    level: Int = INFO,
    t: Throwable? = null,
  ) {
    val logLevel = if (level == WARN) Level.WARNING else Level.INFO

     *
     * The connect timeout is applied when connecting a TCP socket to the target host. The default
     * value is 10 seconds.
     */
    fun connectTimeout(
      timeout: Long,
      unit: TimeUnit,
    ) = apply {
      connectTimeout = checkDuration("timeout", timeout, unit)
    }

    /**
     * Sets the default connect timeout for new connections. A value of 0 means no timeout,

    override: OverrideParam =
      burstValues(
        OverrideParam.Authenticator,
        OverrideParam.Cache,
        OverrideParam.CertificatePinner,
        OverrideParam.ConnectTimeout,
        OverrideParam.ConnectionPool,
        OverrideParam.CookieJar,
        OverrideParam.Dns,
        OverrideParam.HostnameVerifier,
        OverrideParam.Proxy,
        OverrideParam.ProxyAuthenticator,

    server.close()

    client =
      client
        .newBuilder()
        .proxySelector(proxySelector)
        .readTimeout(Duration.ofMillis(100))
        .connectTimeout(Duration.ofMillis(100))
        .build()

    val request = Request(server.url("/"))
    assertFailsWith<IOException> {
      client.newCall(request).execute()
    }.also { expected ->

      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    response.body.close()
  }

  @Test
  fun connectTimeout() {
    val interceptor1 =
      Interceptor { chainA: Interceptor.Chain ->
        assertThat(chainA.connectTimeoutMillis()).isEqualTo(5000)
        val chainB = chainA.withConnectTimeout(100, TimeUnit.MILLISECONDS)

            }
            return message;
        }
    }

    private void reconnect() throws IOException {
        final int readTimeout = getReadTimeout();
        final int connectTimeout = getConnectTimeout();

        HostnameVerifier hv = null;
        SSLSocketFactory ssf = null;
        if (this.connection instanceof HttpsURLConnection) {