builder.followSslRedirects(followRedirects)
    if (connectTimeout != DEFAULT_TIMEOUT) {
      builder.connectTimeout(connectTimeout.toLong(), SECONDS)
    }
    if (readTimeout != DEFAULT_TIMEOUT) {
      builder.readTimeout(readTimeout.toLong(), SECONDS)
    }
    if (callTimeout != DEFAULT_TIMEOUT) {
      builder.callTimeout(callTimeout.toLong(), SECONDS)
    }
    if (allowInsecure) {

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

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

        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build()

    // Copy to customize OkHttp for this request.
    val client1 =
      client.newBuilder()
        .readTimeout(500, TimeUnit.MILLISECONDS)
        .build()
    try {
      client1.newCall(request).execute().use { response ->
        println("Response 1 succeeded: $response")
      }
    } catch (e: IOException) {

import okhttp3.WebSocketListener;
import okio.ByteString;

public final class WebSocketEcho extends WebSocketListener {
  private void run() {
    OkHttpClient client = new OkHttpClient.Builder()
        .readTimeout(0,  TimeUnit.MILLISECONDS)
        .build();

    Request request = new Request.Builder()
        .url("ws://echo.websocket.org")
        .build();
    client.newWebSocket(request, 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

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

        .build(),
    )
    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)

    )
    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 =
      client2

    // headers, but there was still no stream to close.
    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
    stream!!.writeTimeout().timeout(chain.writeTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)
  }

  override fun flushRequest() {