}
    if (responseBodyBytes != null) {
      val responseBodyEnd: ResponseBodyEnd = listener.removeUpToEvent<ResponseBodyEnd>()
      MatcherAssert.assertThat(
        "response body bytes",
        responseBodyEnd.bytesRead,
        responseBodyBytes,
      )
    } else {
      assertThat(listener.recordedEventTypes()).doesNotContain("ResponseBodyEnd")
    }
  }

    logWithTime("responseBodyStart")

    delegate.responseBodyStart(call)
  }

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

    delegate.responseBodyEnd(call, byteCount)
  }

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

01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] responseBodyStart
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] responseBodyEnd: byteCount=128
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] connectionReleased
01-01 12:53:32.811 10999 11089 D OkHttp  : [49 ms] callEnd
01-01 12:53:32.816 10999 11090 D OkHttp  : [54 ms] responseHeadersStart

  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 responseFailed(
    call: Call,
    ioe: IOException,
  ) = logEvent(ResponseFailed(System.nanoTime(), call, ioe))

    logWithTime("responseHeadersEnd: $response")
  }

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

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

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

      .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()
  }

  @Test
  fun post() {
    assumeNotWindows()

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

  /**

	public fun requestFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	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

  }

  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

    expectedEvents += "RequestFailed"
    expectedEvents += "ResponseHeadersStart"
    expectedEvents += "ResponseHeadersEnd"
    expectedEvents += "ResponseBodyStart"
    expectedEvents += "ResponseBodyEnd"
    expectedEvents += "ConnectionReleased"
    expectedEvents += "CallEnd"
    assertThat(listener.recordedEventTypes()).isEqualTo(expectedEvents)