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
        .Builder()

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

        .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 ->

=== ":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 client =
      clientTestRule
        .newClientBuilder()
        .dns { listOf(InetAddress.getByName("localhost")) }
        .callTimeout(4, SECONDS)
        .writeTimeout(2, SECONDS)
        .readTimeout(2, SECONDS)
        .apply {
          if (socketMode is TlsInstance) {
            if (socketMode.socketMode == Channel) {
              socketFactory(ChannelSocketFactory())
            }

    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 {

      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

    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 =

  private val serverListener = WebSocketRecorder("server")
  private val random = Random(0)
  private var client =
    clientTestRule
      .newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->
          val response = chain.proceed(chain.request())
          // Ensure application interceptors never see a null body.

    server!!.enqueue(
      MockResponse
        .Builder()
        .headersDelay(2, TimeUnit.SECONDS)
        .build(),
    )
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofMillis(250))
        .build()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server!!.url("/"))
          .build(),
      )