}

    @Override public void responseBodyStart(Call call) {
      printEvent("responseBodyStart");
    }

    @Override public void responseBodyEnd(Call call, long byteCount) {
      printEvent("responseBodyEnd");
    }

    @Override public void responseFailed(Call call, IOException ioe) {
      printEvent("responseFailed");
    }

    @Override public void callEnd(Call call) {

        eventListener.requestBodyEnd(call, bytesRead)
      }
    }
    if (responseDone) {
      if (e != null) {
        eventListener.responseFailed(call, e)
      } else {
        eventListener.responseBodyEnd(call, bytesRead)
      }
    }
    return call.messageDone(this, requestDone, responseDone, e)
  }

  fun noRequestBody() {
    call.messageDone(this, requestDone = true, responseDone = false, e = null)

response only if the response code is HTTP/1.1 304 Not Modified.
 
 - CallStart
 - **CacheConditionalHit**
 - ConnectionAcquired
 - ... Standard Events...
 - ResponseBodyEnd _(0 bytes)_
 - **CacheHit**
 - ConnectionReleased
 - CallEnd
 
## Cache directory

The cache directory must be exclusively owned by a single instance.

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

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

  private fun newEventSource(accept: String? = null): EventSource {
    val builder =
      Request.Builder()

	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

 *        * 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,

        "ConnectStart", "SecureConnectStart", "SecureConnectEnd", "ConnectEnd",
        "ConnectionAcquired", "RequestHeadersStart", "RequestHeadersEnd", "ResponseHeadersStart",
        "ResponseHeadersEnd", "ResponseBodyStart", "ResponseBodyEnd", "ConnectionReleased",
        "CallEnd",
      ),
      eventListener.recordedEventTypes(),
    )

    eventListener.clearAllEvents()

    client.newCall(request).execute().use { response ->

        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,
          ioe: IOException,
        ) = TODO()