) {
    logWithTime("cacheConditionalHit")

    delegate.cacheConditionalHit(call, cachedResponse)
  }

  override fun retryDecision(
    call: Call,
    exception: IOException,
    retry: Boolean,
  ) {
    logWithTime("retryDecision")

    delegate.retryDecision(call, exception, retry)
  }

  override fun followUpDecision(
    call: Call,
    networkResponse: Response,

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) = logEvent(CacheConditionalHit(System.nanoTime(), call))

  override fun retryDecision(
    call: Call,
    exception: IOException,
    retry: Boolean,
  ) = logEvent(RetryDecision(System.nanoTime(), call, exception, retry))

  override fun followUpDecision(
    call: Call,
    networkResponse: Response,
    nextRequest: Request?,

      "ConnectEnd",
      "ConnectionAcquired",
      "RequestHeadersStart",
      "RequestHeadersEnd",
      "ResponseFailed",
      "RetryDecision",
      "ConnectionReleased",
      "CallFailed",
    )
    assertThat(listener.findEvent<RetryDecision>()).all {
      prop(RetryDecision::retry).isFalse()
    }
  }

  @Test
  fun failedDribbledCallEventSequence() {
    server.enqueue(
      MockResponse

    override val call: Call,
  ) : CallEvent()

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

  data class RetryDecision(
    override val timestampNs: Long,
    override val call: Call,
    val exception: IOException,
    val retry: Boolean,
  ) : CallEvent()

  data class FollowUpDecision(

   * established from a planned [Route]. OkHttp won't retry if it's already attempted all
   * available routes.
   *
   * @param retry true if OkHttp will make another attempt
   */
  open fun retryDecision(
    call: Call,
    exception: IOException,
    retry: Boolean,
  ) {
  }

  /**
   * Invoked when OkHttp decides whether to perform a follow-up request.
   *

        } catch (e: IOException) {
          // An attempt to communicate with a server failed. The request may have been sent.
          val isRecoverable = recover(e, call, request)
          call.eventListener.retryDecision(call, e, isRecoverable)
          if (!isRecoverable) throw e.withSuppressed(recoveredFailures)
          recoveredFailures += e
          newRoutePlanner = false
          continue
        }

      "RequestHeadersEnd",
      "RequestBodyStart",
      "RequestBodyEnd",
      "ResponseFailed",
      "RetryDecision",
      "ConnectionReleased",
      "CallFailed",
    )
    assertThat(listener.findEvent<RetryDecision>()).all {
      prop(RetryDecision::retry).isFalse()
    }
    listener.clearAllEvents()

    val response3 = client.newCall(request1).execute()

 *  Fix: Change the signature of `Dispatcher` to accept a nullable `ExecutorService`. Changing this
    parameter to be non-null was an unintended signature change in OkHttp 4.0.

 *  New: `EventListener.retryDecision()` is called each time a request fails with an `IOException`.
    It notifies your listener if OkHttp will retry.

 *  New: `EventListener.followUpDecision()` is called each time a response is received. It notifies

	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 retryDecision (Lokhttp3/Call;Ljava/io/IOException;Z)V
	public fun satisfactionFailure (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun secureConnectEnd (Lokhttp3/Call;Lokhttp3/Handshake;)V
	public fun secureConnectStart (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 retryDecision (Lokhttp3/Call;Ljava/io/IOException;Z)V
	public fun satisfactionFailure (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun secureConnectEnd (Lokhttp3/Call;Lokhttp3/Handshake;)V
	public fun secureConnectStart (Lokhttp3/Call;)V