.eventListenerFactory(loggingEventListenerFactory)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .retryOnConnectionFailure(false)
        .build()
    url = server.url("/")
  }

  @Test
  fun get() {
    assumeNotWindows()
    server.enqueue(
      MockResponse.Builder()
        .body("Hello!")

    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

   * 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 =
      MockStreamHandler()
        .sendResponse("success!")

        }
      }
    client =
      client.newBuilder()
        .dns(DoubleInetAddressDns())
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
    assertThat(client.retryOnConnectionFailure).isTrue()
    executeSynchronously("/").assertBody("seed connection pool")
    executeSynchronously("/").assertBody("retry success")

    // The call that seeds the connection pool.

	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

    server.enqueue(
      MockResponse(socketPolicy = ResetStreamAtStart(errorCode!!.httpCode)),
    )
    server.enqueue(MockResponse(body = "abc"))
    client =
      client.newBuilder()
        .retryOnConnectionFailure(false)
        .build()
    val call = client.newCall(Request(server.url("/")))
    assertFailsWith<StreamResetException> {
      call.execute()
    }.also { expected ->

 *  Fix: Don't drop headers of healthy streams that raced with `GOAWAY` frames.
    This bug would cause HTTP/2 streams to occasional hang when the connection
    was shutting down.
 *  Fix: Honor `OkHttpClient.retryOnConnectionFailure()` when the response is a
    HTTP 408 Request Timeout. If retries are enabled, OkHttp will retry exactly
    once in response to a 408.
 *  Fix: Don't crash when reading the empty `HEAD` response body if it specifies