): ConnectPlan {
    return ConnectPlan(
      taskRunner = taskRunner,
      connectionPool = connectionPool,
      readTimeoutMillis = readTimeoutMillis,
      writeTimeoutMillis = writeTimeoutMillis,
      socketConnectTimeoutMillis = socketConnectTimeoutMillis,
      socketReadTimeoutMillis = socketReadTimeoutMillis,
      pingIntervalMillis = pingIntervalMillis,

        index = 0,
        exchange = null,
        request = originalRequest,
        connectTimeoutMillis = client.connectTimeoutMillis,
        readTimeoutMillis = client.readTimeoutMillis,
        writeTimeoutMillis = client.writeTimeoutMillis,
      )

    var calledNoMoreExchanges = false
    try {
      val response = chain.proceed(originalRequest)
      if (isCanceled()) {
        response.closeQuietly()

        else -> null
      }

    return ConnectPlan(
      taskRunner = taskRunner,
      connectionPool = connectionPool,
      readTimeoutMillis = readTimeoutMillis,
      writeTimeoutMillis = writeTimeoutMillis,
      socketConnectTimeoutMillis = socketConnectTimeoutMillis,
      socketReadTimeoutMillis = socketReadTimeoutMillis,
      pingIntervalMillis = pingIntervalMillis,

Cleanup_ for a safe and fast upgrade.


Backwards-Incompatible Changes
------------------------------

#### OkHttpClient final methods

`OkHttpClient` has 26 accessors like `interceptors()` and `writeTimeoutMillis()` that were non-final
in OkHttp 3.x and are final in 4.x. These were made non-final for use with mocking frameworks like
[Mockito][mockito]. We believe subtyping `OkHttpClient` is the wrong way to test with OkHttp. If

    val callTimeoutMillis: Int = client.callTimeoutMillis()
    val connectTimeoutMillis: Int = client.connectTimeoutMillis()
    val readTimeoutMillis: Int = client.readTimeoutMillis()
    val writeTimeoutMillis: Int = client.writeTimeoutMillis()
    val pingIntervalMillis: Int = client.pingIntervalMillis()
  }

  @Test @Disabled
  fun pushPromise() {
    val pushPromise = PushPromise("", "", Headers.of(), MockResponse())

        assertThat(chainA.writeTimeoutMillis()).isEqualTo(5000)
        val chainB = chainA.withWriteTimeout(100, TimeUnit.MILLISECONDS)
        assertThat(chainB.writeTimeoutMillis()).isEqualTo(100)
        chainB.proceed(chainA.request())
      }
    val interceptor2 =
      Interceptor { chain: Interceptor.Chain ->
        assertThat(chain.writeTimeoutMillis()).isEqualTo(100)
        chain.proceed(chain.request())

    assertThat(client.callTimeoutMillis).isEqualTo(0)
    assertThat(client.connectTimeoutMillis).isEqualTo(10000)
    assertThat(client.readTimeoutMillis).isEqualTo(10000)
    assertThat(client.writeTimeoutMillis).isEqualTo(10000)
    assertThat(client.pingIntervalMillis).isEqualTo(0)
    assertThat(client.webSocketCloseTimeout).isEqualTo(60_000)
  }

  @Test fun webSocketDefaults() {

    val callTimeoutMillis: Int = client.callTimeoutMillis
    val connectTimeoutMillis: Int = client.connectTimeoutMillis
    val readTimeoutMillis: Int = client.readTimeoutMillis
    val writeTimeoutMillis: Int = client.writeTimeoutMillis
    val pingIntervalMillis: Int = client.pingIntervalMillis
    val call: Call = client.newCall(Request.Builder().build())
    val webSocket: WebSocket =
      client.newWebSocket(

      call = call,
      interceptors = listOf(),
      index = 0,
      exchange = null,
      request = call.request(),
      connectTimeoutMillis = 10_000,
      readTimeoutMillis = 10_000,
      writeTimeoutMillis = 10_000,
    )
  }

  companion object {
    private const val PROXY_A_PORT = 1001
    private const val PROXY_A_HOST = "proxya"
    private val proxyA =
      Proxy(
        Proxy.Type.HTTP,

    } else {
      socket.soTimeout = chain.readTimeoutMillis()
      source.timeout().timeout(chain.readTimeoutMillis.toLong(), MILLISECONDS)
      sink.timeout().timeout(chain.writeTimeoutMillis.toLong(), MILLISECONDS)
      Http1ExchangeCodec(client, this, source, sink)
    }
  }

  @Throws(SocketException::class)
  internal fun newWebSocketStreams(exchange: Exchange): RealWebSocket.Streams {