get() = 10

      override fun isDefaultValue(value: Int): Boolean = value == 10000
    }

    object ReadTimeoutOverride : Override<Int> {
      override fun Interceptor.Chain.value(): Int = readTimeoutMillis()

      override fun Interceptor.Chain.withOverride(value: Int): Interceptor.Chain = withReadTimeout(value, TimeUnit.MILLISECONDS)

	public abstract fun getX509TrustManagerOrNull ()Ljavax/net/ssl/X509TrustManager;
	public abstract fun proceed (Lokhttp3/Request;)Lokhttp3/Response;
	public abstract fun readTimeoutMillis ()I
	public abstract fun request ()Lokhttp3/Request;
	public abstract fun withAuthenticator (Lokhttp3/Authenticator;)Lokhttp3/Interceptor$Chain;
	public abstract fun withCache (Lokhttp3/Cache;)Lokhttp3/Interceptor$Chain;

	public abstract fun getX509TrustManagerOrNull ()Ljavax/net/ssl/X509TrustManager;
	public abstract fun proceed (Lokhttp3/Request;)Lokhttp3/Response;
	public abstract fun readTimeoutMillis ()I
	public abstract fun request ()Lokhttp3/Request;
	public abstract fun withAuthenticator (Lokhttp3/Authenticator;)Lokhttp3/Interceptor$Chain;
	public abstract fun withCache (Lokhttp3/Cache;)Lokhttp3/Interceptor$Chain;

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

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

    // 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() {
    http2Connection.flush()
  }

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