this.onRequestStart = builder.onRequestStart
    this.doNotReadRequestBody = builder.doNotReadRequestBody
    this.onRequestBody = builder.onRequestBody
    this.onResponseStart = builder.onResponseStart
    this.onResponseBody = builder.onResponseBody
    this.onResponseEnd = builder.onResponseEnd
    this.shutdownServer = builder.shutdownServer
    this.headersDelayNanos = builder.headersDelayNanos

    SocketPolicy.DISCONNECT_AT_END -> 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 -> result.onResponseBody(CloseSocket())

    }
  }

  @Test
  fun failedCall() {
    runTest {
      server.enqueue(
        MockResponse
          .Builder()
          .body("abc")
          .onResponseStart(SocketEffect.ShutdownConnection)
          .build(),
      )

      val call = client.newCall(request)

      assertFailsWith<IOException> {
        call.executeAsync().use {

  }

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

        .build()
    websocketScheme("https")
  }

  @Test
  fun readTimeoutAppliesToHttpRequest() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .onResponseStart(Stall)
        .build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertFailure(
      SocketTimeoutException::class.java,
      "timeout",
      "Read timed out",
    )

      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)

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

	public final fun onResponseBody (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onResponseEnd (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onResponseStart (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun removeHeader (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;

  }

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun readResponseHeaderTimeout(protocol: Protocol) {
    setUp(protocol)
    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 =