socketFactory[ipv6] = server1.socketAddress
    socketFactory[ipv4] = server2.socketAddress

    client =
      client
        .newBuilder()
        .fastFallback(false)
        .apply {
          retryOnConnectionFailure = false
        }.build()

    executeSynchronously(request)
      .assertFailureMatches("stream was reset: REFUSED_STREAM")

    assertThat(client.routeDatabase.failedRoutes).isEmpty()

      socketConnectTimeoutMillis = socketConnectTimeoutMillis,
      socketReadTimeoutMillis = socketReadTimeoutMillis,
      pingIntervalMillis = pingIntervalMillis,
      retryOnConnectionFailure = retryOnConnectionFailure,
      call = call,
      routePlanner = routePlanner,
      route = route,
      routes = routes,
      attempt = attempt,
      tunnelRequest = tunnelRequest,

     * calling application should do its own recovery of connectivity failures.
     */
    fun retryOnConnectionFailure(retryOnConnectionFailure: Boolean) =
      apply {
        this.retryOnConnectionFailure = retryOnConnectionFailure
      }

    /**
     * Configure this client to perform fast fallbacks by attempting multiple connections

      socketConnectTimeoutMillis = chain.connectTimeoutMillis,
      socketReadTimeoutMillis = chain.readTimeoutMillis,
      pingIntervalMillis = client.pingIntervalMillis,
      retryOnConnectionFailure = client.retryOnConnectionFailure,
      fastFallback = client.fastFallback,
      address = address,
      routeDatabase = client.routeDatabase,
      call = call,
      request = call.request(),
    )
  }

      socketConnectTimeoutMillis = socketConnectTimeoutMillis,
      socketReadTimeoutMillis = socketReadTimeoutMillis,
      pingIntervalMillis = pingIntervalMillis,
      retryOnConnectionFailure = retryOnConnectionFailure,
      call = call,
      routePlanner = this,
      route = route,
      routes = routes,
      attempt = 0,
      tunnelRequest = tunnelRequest,
      connectionSpecIndex = -1,

          socketConnectTimeoutMillis = chain.connectTimeoutMillis,
          socketReadTimeoutMillis = chain.readTimeoutMillis,
          pingIntervalMillis = client.pingIntervalMillis,
          retryOnConnectionFailure = client.retryOnConnectionFailure,
          fastFallback = client.fastFallback,
          address = client.address(request.url),
          routeDatabase = client.routeDatabase,
          call = this,

    val dns: Dns = client.dns
    val followSslRedirects: Boolean = client.followSslRedirects
    val followRedirects: Boolean = client.followRedirects
    val retryOnConnectionFailure: Boolean = client.retryOnConnectionFailure
    val callTimeoutMillis: Int = client.callTimeoutMillis
    val connectTimeoutMillis: Int = client.connectTimeoutMillis
    val readTimeoutMillis: Int = client.readTimeoutMillis

  /**
   * Invoked when OkHttp decides whether to retry after a connectivity failure.
   *
   * OkHttp won't retry when it is configured not to:
   *
   *  * If retries are forbidden with [OkHttpClient.retryOnConnectionFailure]. (OkHttp's defaults
   *    permit retries.)
   *  * If OkHttp already attempted to transmit the request body, and [RequestBody.isOneShot] is
   *    true.
   *

	public final fun proxyAuthenticator ()Lokhttp3/Authenticator;
	public final fun proxySelector ()Ljava/net/ProxySelector;
	public final fun readTimeoutMillis ()I
	public final fun retryOnConnectionFailure ()Z
	public final fun socketFactory ()Ljavax/net/SocketFactory;
	public final fun sslSocketFactory ()Ljavax/net/ssl/SSLSocketFactory;
	public final fun webSocketCloseTimeout ()I

   * be readable after the request stream is canceled.
   */
  @Disabled
  @Test
  fun serverCancelsRequestBodyAndSendsResponseBody() {
    client =
      client
        .newBuilder()
        .retryOnConnectionFailure(false)
        .build()
    val log: BlockingQueue<String?> = LinkedBlockingQueue()
    enableProtocol(Protocol.HTTP_2)
    val body =
      MockSocketHandler()
        .sendResponse("success!")