response: Response,
  ) {
    logWithTime("responseHeadersEnd: $response")

    delegate.responseHeadersEnd(call, response)
  }

  override fun responseBodyStart(call: Call) {
    logWithTime("responseBodyStart")

    delegate.responseBodyStart(call)
  }

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

      "ConnectStart", "ConnectEnd", "ConnectionAcquired", "RequestHeadersStart",
      "RequestHeadersEnd", "ResponseHeadersStart", "ResponseHeadersEnd", "ResponseBodyStart",
      "ResponseBodyEnd", "RequestHeadersStart", "RequestHeadersEnd", "ResponseHeadersStart",
      "ResponseHeadersEnd", "ResponseBodyStart", "ResponseBodyEnd", "ConnectionReleased",
      "CallEnd",
    )
  }

  @Test

      if (completed) return e
      completed = true
      // If the body is closed without reading any bytes send a responseBodyStart() now.
      if (e == null && invokeStartEvent) {
        invokeStartEvent = false
        eventListener.responseBodyStart(call)
      }
      return bodyComplete(bytesReceived, responseDone = true, requestDone = false, e = e)
    }
  }

  }

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

  data class ResponseBodyEnd(
    override val timestampNs: Long,
    override val call: Call,
    val bytesRead: Long,
  ) : CallEvent() {
    override fun closes(event: CallEvent): Boolean = event is ResponseBodyStart && call == event.call
  }

 *        * body ([requestBodyStart], [requestBodyEnd])
 *      * response ([responseFailed])
 *        * headers ([responseHeadersStart], [responseHeadersEnd])
 *        * body ([responseBodyStart], [responseBodyEnd])
 *
 * This nesting is typical but not strict. For example, when calls use "Expect: continue" the
 * request body start and end events occur within the response header events. Similarly,

  override fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) = logEvent(ResponseHeadersEnd(System.nanoTime(), call, response.headers.byteCount()))

  override fun responseBodyStart(call: Call) = logEvent(ResponseBodyStart(System.nanoTime(), call))

  override fun responseBodyEnd(
    call: Call,
    byteCount: Long,
  ) = logEvent(ResponseBodyEnd(System.nanoTime(), call, byteCount))

  }

  override fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) {
    logWithTime("responseHeadersEnd: $response")
  }

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

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

      .assertLogMatch(Regex("""responseHeadersStart"""))
      .assertLogMatch(Regex("""responseHeadersEnd: Response\{protocol=http/1\.1, code=200, message=OK, url=$url\}"""))
      .assertLogMatch(Regex("""responseBodyStart"""))
      .assertLogMatch(Regex("""responseBodyEnd: byteCount=6"""))
      .assertLogMatch(Regex("""connectionReleased"""))
      .assertLogMatch(Regex("""callEnd"""))
      .assertNoMoreLogs()
  }

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

  /**

	public fun requestHeadersEnd (Lokhttp3/Call;Lokhttp3/Request;)V
	public fun requestHeadersStart (Lokhttp3/Call;)V
	public fun responseBodyEnd (Lokhttp3/Call;J)V
	public fun responseBodyStart (Lokhttp3/Call;)V
	public fun responseFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun responseHeadersEnd (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun responseHeadersStart (Lokhttp3/Call;)V