) {
    logWithTime("responseBodyEnd: byteCount=$byteCount")

    delegate.responseBodyEnd(call, byteCount)
  }

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

    delegate.responseFailed(call, ioe)
  }

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

    delegate.callEnd(call)
  }

    try {
      val result = codec.readResponseHeaders(expectContinue)
      result?.initExchange(this)
      return result
    } catch (e: IOException) {
      eventListener.responseFailed(call, e)
      trackFailure(e)
      throw e
    }
  }

  fun responseHeadersEnd(response: Response) {
    eventListener.responseHeadersEnd(call, response)
  }

  @Throws(IOException::class)

import okhttp3.CallEvent.ConnectEnd
import okhttp3.CallEvent.ConnectStart
import okhttp3.CallEvent.ConnectionAcquired
import okhttp3.CallEvent.ConnectionReleased
import okhttp3.CallEvent.RequestFailed
import okhttp3.CallEvent.ResponseFailed
import okhttp3.DelegatingServerSocketFactory
import okhttp3.DelegatingSocketFactory
import okhttp3.MediaType
import okhttp3.OkHttpClient
import okhttp3.OkHttpClientTestRule
import okhttp3.Protocol.HTTP_1_1

    }

    @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) {
      printEvent("callEnd");
    }

    @Override public void callFailed(Call call, IOException ioe) {

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

  override fun callEnd(call: Call) = logEvent(CallEnd(System.nanoTime(), call))

  override fun callFailed(
    call: Call,

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

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

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

  override fun callFailed(
    call: Call,
    ioe: IOException,

    }

    @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) {
      printEvent("callEnd");
    }

    @Override public void callFailed(Call call, IOException ioe) {

      "RequestHeadersEnd", "ResponseHeadersStart", "ResponseHeadersEnd", "ResponseBodyStart",
      "ResponseFailed", "ConnectionReleased", "CallFailed",
    )
    val responseFailed = listener.removeUpToEvent<ResponseFailed>()
    assertThat(responseFailed.ioe.message).isEqualTo("unexpected end of stream")
  }

  @Test
  fun canceledCallEventSequence() {
    val call =

	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
	public fun satisfactionFailure (Lokhttp3/Call;Lokhttp3/Response;)V

 *      * request ([requestFailed])
 *        * headers ([requestHeadersStart], [requestHeadersEnd])
 *        * 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