) {
      for (delegate in eventListeners) {
        delegate.responseHeadersEnd(call, response)
      }
    }

    override fun responseBodyStart(call: Call) {
      for (delegate in eventListeners) {
        delegate.responseBodyStart(call)
      }
    }

    override fun responseBodyEnd(
      call: Call,
      byteCount: Long,
    ) {
      for (delegate in eventListeners) {

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

      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
        call.eventListener.responseBodyStart(call)
      }
      return bodyComplete(
        bytesRead = bytesReceived,
        isSocket = isSocket,
        responseDone = true,

      ResponseHeadersStart::class,
      ResponseHeadersEnd::class,
      ResponseBodyStart::class,
      ResponseBodyEnd::class,
      FollowUpDecision::class,
      RequestHeadersStart::class,
      RequestHeadersEnd::class,
      ResponseHeadersStart::class,
      ResponseHeadersEnd::class,
      FollowUpDecision::class,
      ResponseBodyStart::class,
      ResponseBodyEnd::class,
      ConnectionReleased::class,

import okhttp3.CallEvent.RequestFailed
import okhttp3.CallEvent.RequestHeadersEnd
import okhttp3.CallEvent.RequestHeadersStart
import okhttp3.CallEvent.ResponseBodyEnd
import okhttp3.CallEvent.ResponseBodyStart
import okhttp3.CallEvent.ResponseHeadersEnd
import okhttp3.CallEvent.ResponseHeadersStart
import okhttp3.CallEvent.SecureConnectEnd
import okhttp3.CallEvent.SecureConnectStart
import okhttp3.Headers.Companion.headersOf

import okhttp3.CallEvent.ProxySelectStart
import okhttp3.CallEvent.RequestHeadersEnd
import okhttp3.CallEvent.RequestHeadersStart
import okhttp3.CallEvent.ResponseBodyEnd
import okhttp3.CallEvent.ResponseBodyStart
import okhttp3.CallEvent.ResponseHeadersEnd
import okhttp3.CallEvent.ResponseHeadersStart
import okhttp3.CallEvent.SecureConnectEnd
import okhttp3.CallEvent.SecureConnectStart
import okhttp3.CertificatePinner

    a stream timeout to determine whether the connection should remain eligible for pooling.

 *  Fix: Don't call `EventListener.responseHeadersStart()` or `responseBodyStart()` until bytes have
    been received. Previously these events were incorrectly sent too early, when OkHttp was ready to
    read the response headers or body, which mislead tracing tools. Note that the `responseFailed()`

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

        override fun responseHeadersEnd(
          call: Call,
          response: Response,
        ) = TODO()

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

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

        override fun responseFailed(
          call: Call,