) {
    logWithTime("requestHeadersEnd")
  }

  override fun requestBodyStart(call: Call) {
    logWithTime("requestBodyStart")
  }

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

  override fun requestFailed(
    call: Call,
    ioe: IOException,
  ) {
    logWithTime("requestFailed: $ioe")
  }

    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,
  ) {

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

    }
    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) {

    e: E,
  ): E {
    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)
      }

	public fun dnsStart (Lokhttp3/Call;Ljava/lang/String;)V
	public fun proxySelectEnd (Lokhttp3/Call;Lokhttp3/HttpUrl;Ljava/util/List;)V
	public fun proxySelectStart (Lokhttp3/Call;Lokhttp3/HttpUrl;)V
	public fun requestBodyEnd (Lokhttp3/Call;J)V
	public fun requestBodyStart (Lokhttp3/Call;)V
	public fun requestFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun requestHeadersEnd (Lokhttp3/Call;Lokhttp3/Request;)V

  }

  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

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

        ),
      )
      .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\}"""))

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

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