),
      )
    assertThat(response.code).isEqualTo(200)
    assertContent("Body", response)
    response.close()
    assertThat(server.requestCount).isEqualTo(2)
  }

  @Test
  fun readTimeouts() {
    // This relies on the fact that MockWebServer doesn't close the
    // connection after a response has been sent. This causes the client to
    // try to read more bytes than are sent, which results in a timeout.

     *
     * @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;
    }

    /**

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

        // ## Assert ##
        // Default timeout values should be -1 (not set)
        assertEquals(-1, request.connectTimeout);
        assertEquals(-1, request.readTimeout);
    }

    @Test
    public void test_TimeoutSetsValues() {
        // ## Arrange ##
        final CurlRequest request = new CurlRequest(Method.GET, "http://example.com");

        // ## Act ##

     * 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

    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.writeTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.readTimeout(Duration.ofNanos(1))
    } catch (ignored: IllegalArgumentException) {
    }
    try {
      builder.callTimeout(Duration.ofDays(365))
    } catch (ignored: IllegalArgumentException) {
    }
    try {

 * @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) {

=== ":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