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

   eventListenerFactory, followRedirects, followSslRedirects, hostnameVerifier, interceptors,
   networkInterceptors, pingIntervalMillis, protocols, proxy, proxyAuthenticator, proxySelector,
   readTimeoutMillis, retryOnConnectionFailure, socketFactory, sslSocketFactory, writeTimeoutMillis
 * **PushPromise**: headers, method, path, response
 * **Request**: body, cacheControl, headers, method, url

    return if (http2Connection != null) {
      Http2ExchangeCodec(client, this, chain, http2Connection)
    } else {
      socket.soTimeout = chain.readTimeoutMillis()
      source.timeout().timeout(chain.readTimeoutMillis.toLong(), MILLISECONDS)
      sink.timeout().timeout(chain.writeTimeoutMillis.toLong(), MILLISECONDS)
      Http1ExchangeCodec(client, this, source, sink)
    }
  }

  @Test fun durationDefaults() {
    val client = clientTestRule.newClient()
    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)
  }

    val retryOnConnectionFailure: Boolean = client.retryOnConnectionFailure
    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())

    return RealInterceptorChain(
      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 =

    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()

    // Sleep longer than the HTTP client's read timeout.
    Thread.sleep((client.readTimeoutMillis + 500).toLong())
    server.send("abc")
    clientListener.assertTextMessage("abc")
    closeWebSockets(webSocket, server)
  }

  @Test
  @Throws(Exception::class)

	public abstract fun connectTimeoutMillis ()I
	public abstract fun connection ()Lokhttp3/Connection;
	public abstract fun proceed (Lokhttp3/Request;)Lokhttp3/Response;
	public abstract fun readTimeoutMillis ()I
	public abstract fun request ()Lokhttp3/Request;
	public abstract fun withConnectTimeout (ILjava/util/concurrent/TimeUnit;)Lokhttp3/Interceptor$Chain;