}

  @Test
  fun silentRetryWhenIdempotentRequestFailsOnReusedConnection() {
    server.enqueue(MockResponse(body = "a"))
    server.enqueue(MockResponse.Builder().onResponseStart(CloseSocket()).build())
    server.enqueue(MockResponse(body = "b"))
    val request = Request(server.url("/"))
    val responseA = client.newCall(request).execute()
    assertThat(responseA.body.string()).isEqualTo("a")

          if (peek().onResponseStart is CloseSocket) {
            requestFinished.await()
          }
          return super.dispatch(request)
        }
      }
    dispatcher.enqueue(MockResponse(body = "seed connection pool"))
    dispatcher.enqueue(MockResponse.Builder().onResponseStart(CloseSocket()).build())
    dispatcher.enqueue(MockResponse(body = "retry success"))

      result.onResponseEnd(ShutdownConnection)
    }

    SocketPolicy.DISCONNECT_AT_START -> {
      result.onRequestStart(CloseSocket())
    }

    SocketPolicy.DISCONNECT_AFTER_REQUEST -> {
      result.onResponseStart(CloseSocket())
    }

    SocketPolicy.DISCONNECT_DURING_REQUEST_BODY -> {
      result.onRequestBody(CloseSocket())
    }

    SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY -> {

      if (request.failure != null) {
        return false // Nothing to respond to.
      }

      val response = dispatcher.dispatch(request)

      try {
        if (handleSocketEffect(response.onResponseStart, socket)) {
          return false
        }

        var reuseSocket = true
        val requestWantsSocket = "Upgrade".equals(request.headers["Connection"], ignoreCase = true)

    assertThat(inputStream.read()).isEqualTo(-1)
    inputStream.close()
  }

  @Test
  fun readResponseHeaderTimeout() {
    server.enqueue(MockResponse.Builder().onResponseStart(Stall).build())
    server.enqueue(MockResponse(body = "A"))
    client =
      client
        .newBuilder()
        .readTimeout(Duration.ofSeconds(1))
        .build()

  }

  @Test
  fun postBodyRetransmittedOnFailureRecovery() {
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse.Builder().onResponseStart(CloseSocket()).build())
    server.enqueue(MockResponse(body = "def"))

    // Seed the connection pool so we have something that can fail.
    assertContent("abc", getResponse(newRequest("/")))
    val post =