logWithTime("requestBodyStart")

    delegate.requestBodyStart(call)
  }

  override fun requestBodyEnd(
    call: Call,
    byteCount: Long,
  ) {
    logWithTime("requestBodyEnd: byteCount=$byteCount")

    delegate.requestBodyEnd(call, byteCount)
  }

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) {

    }
    if (requestBodyBytes != null) {
      val responseBodyEnd: RequestBodyEnd = listener.removeUpToEvent<RequestBodyEnd>()
      MatcherAssert.assertThat(
        "request body bytes",
        responseBodyEnd.bytesWritten,
        requestBodyBytes,
      )
    } else {
      assertThat(listener.recordedEventTypes()).doesNotContain("RequestBodyEnd")
    }
    if (responseHeaderLength != null) {

  override fun requestBodyStart(call: Call) = logEvent(RequestBodyStart(System.nanoTime(), call))

  override fun requestBodyEnd(
    call: Call,
    byteCount: Long,
  ) = logEvent(RequestBodyEnd(System.nanoTime(), call, byteCount))

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) = logEvent(RequestFailed(System.nanoTime(), call, ioe))

      assertThat(response.code).isEqualTo(200)
      assertThat(response.socket).isNull()
      assertThat(response.body.string()).isEqualTo("normal request")
    }
    // Confirm there's no RequestBodyStart/RequestBodyEnd on failed upgrades.
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",
      "ProxySelectStart",
      "ProxySelectEnd",
      "DnsStart",
      "DnsEnd",

 *    * connection held ([connectionAcquired], [connectionReleased])
 *      * request ([requestFailed])
 *        * headers ([requestHeadersStart], [requestHeadersEnd])
 *        * body ([requestBodyStart], [requestBodyEnd])
 *      * response ([responseFailed])
 *        * headers ([responseHeadersStart], [responseHeadersEnd])
 *        * body ([responseBodyStart], [responseBodyEnd])
 *

  }

  data class RequestBodyStart(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class RequestBodyEnd(
    override val timestampNs: Long,
    override val call: Call,
    val bytesWritten: Long,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is RequestBodyStart && call == event.call

  ): IOException? {
    if (e != null) {
      trackFailure(e)
    }
    if (requestDone) {
      if (e != null) {
        eventListener.requestFailed(call, e)
      } else {
        eventListener.requestBodyEnd(call, bytesRead)
      }
    }
    if (responseDone) {
      if (e != null) {
        eventListener.responseFailed(call, e)
      } else {
        eventListener.responseBodyEnd(call, bytesRead)
      }

        ),
      ).assertLogMatch(Regex("""requestHeadersStart"""))
      .assertLogMatch(Regex("""requestHeadersEnd"""))
      .assertLogMatch(Regex("""requestBodyStart"""))
      .assertLogMatch(Regex("""requestBodyEnd: byteCount=6"""))
      .assertLogMatch(Regex("""responseHeadersStart"""))
      .assertLogMatch(Regex("""responseHeadersEnd: Response\{protocol=http/1\.1, code=200, message=OK, url=$url\}"""))

      "RequestHeadersEnd",
      "RequestBodyStart",
      "ResponseHeadersStart",
      "ResponseHeadersEnd",
      "FollowUpDecision",
      "ResponseBodyStart",
      "ResponseBodyEnd",
      "RequestBodyEnd",
      "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test
  fun duplexWith100Continue() {
    enableProtocol(Protocol.HTTP_2)
    val body =
      MockSocketHandler()

        override fun requestHeadersEnd(
          call: Call,
          request: Request,
        ) = TODO()

        override fun requestBodyStart(call: Call) = TODO()

        override fun requestBodyEnd(
          call: Call,
          byteCount: Long,
        ) = TODO()

        override fun requestFailed(
          call: Call,
          ioe: IOException,
        ) = TODO()