*
     * @param connectTimeout the connection timeout in milliseconds
     * @param readTimeout the read timeout in milliseconds
     * @return this CurlRequest instance
     */
    public CurlRequest timeout(final int connectTimeout, final int readTimeout) {
        this.connectTimeout = connectTimeout;
        this.readTimeout = readTimeout;
        return this;
    }

    /**

     * including on [Source] of the [Response]. The default value is 10 seconds.
     *
     * @see Socket.setSoTimeout
     * @see Source.timeout
     */
    fun readTimeout(
      timeout: Long,
      unit: TimeUnit,
    ) = apply {
      readTimeout = checkDuration("timeout", timeout, unit)
    }

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

        val doReadTimeout = callerIsIdle || doReadTimeout()
        if (doReadTimeout) {
          readTimeout.enter()
        }
        try {
          waitForIo()
        } finally {
          if (doReadTimeout) {
            readTimeout.exitAndThrowIfTimedOut()
          }
        }
      }
      if (headersQueue.isNotEmpty()) {
        return headersQueue.removeFirst()

        .url(server.url("/"))
        .post(DelayedRequestBody("hello".toRequestBody(null), 1500, TimeUnit.MILLISECONDS))
        .build()
    client =
      client
        .newBuilder()
        .readTimeout(1000, TimeUnit.MILLISECONDS)
        .build()
    val call = client.newCall(request)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->

 * @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
    }
  } catch (_: SocketTimeoutException) {
    true // Read timed out; socket is good.
  } catch (_: IOException) {

        OverrideParam.Dns,
        OverrideParam.HostnameVerifier,
        OverrideParam.Proxy,
        OverrideParam.ProxyAuthenticator,
        OverrideParam.ProxySelector,
        OverrideParam.ReadTimeout,
        OverrideParam.RetryOnConnectionFailure,
        OverrideParam.SocketFactory,
        OverrideParam.SslSocketFactory,
        OverrideParam.WriteTimeout,
        OverrideParam.X509TrustManager,
      ),

=== ":material-language-kotlin: Kotlin"
    ```kotlin
      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.Builder()

    val client1 =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(2))
        .build()
    val call1 =
      client1
        .newCall(
          Request
            .Builder()
            .url(server.url("/"))
            .build(),
        )
    val client2 =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(200))
        .build()
    val call2 =

      env:
        # Set the DEVELOCITY_ACCESS_KEY so that a Build Scan is generated
        DEVELOCITY_ACCESS_KEY: ${{ secrets.DEVELOCITY_ACCESS_KEY }}
        # Potential stop-gap solution for ReadTimeout issues with the Gradle Build Cache
        # https://gradle.slack.com/archives/CHDLT99C6/p1636477584059200
        GRADLE_OPTS: -Dhttp.keepAlive=false

    - name: Compile with Gradle without publishing a Build Scan

    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("DEF")
        .build(),
    )
    val urlConnection = server.url("/").toUrl().openConnection()
    urlConnection!!.readTimeout = 1000
    val inputStream = urlConnection.getInputStream()
    assertThat(inputStream!!.read()).isEqualTo('A'.code)
    assertThat(inputStream.read()).isEqualTo('B'.code)