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
    this.bodyDelayNanos = builder.bodyDelayNanos

    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .trailers(headersOf("t1", "v2"))
        .body(protocol, "Hello")
        .onResponseBody(CloseSocket())
        .build(),
    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      assertFailsWith<IOException> {
        response.trailers()

  @Test
  fun failedDribbledCallEventSequence() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("0123456789")
        .throttleBody(2, 100, TimeUnit.MILLISECONDS)
        .onResponseBody(CloseSocket())
        .build(),
    )
    client =
      client
        .newBuilder()
        .protocols(listOf<Protocol>(Protocol.HTTP_1_1))
        .readTimeout(Duration.ofMillis(250))

	public final fun onRequestBody (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onRequestStart (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onResponseBody (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;
	public final fun onResponseEnd (Lmockwebserver3/SocketEffect;)Lmockwebserver3/MockResponse$Builder;

    assertThat(i.toFloat()).isCloseTo(512f, 5f)
  }

  @Test
  fun disconnectResponseHalfway() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("ab")
        .onResponseBody(CloseSocket())
        .build(),
    )
    val connection = server.url("/").toUrl().openConnection()
    assertThat(connection!!.contentLength).isEqualTo(2)
    val inputStream = connection.getInputStream()

    }

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

    SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY -> {
      result.onResponseBody(CloseSocket())
    }

    SocketPolicy.DO_NOT_READ_REQUEST_BODY -> {
      result.doNotReadRequestBody()
    }

    SocketPolicy.FAIL_HANDSHAKE -> {
      result.failHandshake()
    }

    socket.sleepWhileOpen(response.bodyDelayNanos)
    val responseBodySink =
      socket.sink
        .withThrottlingAndSocketEffect(
          policy = response,
          socketEffect = response.onResponseBody,
          expectedByteCount = body.contentLength,
          socket = socket,
        ).buffer()
    body.writeTo(responseBodySink)
    responseBodySink.emit()