bus.register(catcher);

    // We post the event, but our Executor will not deliver it until instructed.
    bus.post(EVENT);

    List<String> events = catcher.getEvents();
    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();

 * #enqueue enqueueing} and then {@linkplain #dispatch dispatching} events.
 *
 * <p>The API of this class is designed to make it easy to achieve the following properties
 *
 * <ul>
 *   <li>Multiple events for the same listener are never dispatched concurrently.
 *   <li>Events for the different listeners are dispatched concurrently.
 *   <li>All events for a given listener dispatch on the provided executor.

import java.util.concurrent.ConcurrentLinkedQueue;

/**
 * Handler for dispatching events to subscribers, providing different event ordering guarantees that
 * make sense for different situations.
 *
 * <p><b>Note:</b> The dispatcher is orthogonal to the subscriber's {@code Executor}. The dispatcher
 * controls the order in which events are dispatched, while the executor controls how (i.e. on which

        # Redirect all feature pages to features/*
        'caching.md': 'features/caching.md'
        'calls.md': 'features/calls.md'
        'connections.md': 'features/connections.md'
        'events.md': 'features/events.md'
        'https.md': 'features/events.md'
        'interceptors.md': 'features/interceptors.md'
        'r8_proguard.md': 'features/r8_proguard.md'
        # Redirect all Security pages to security/*

 * #enqueue enqueueing} and then {@linkplain #dispatch dispatching} events.
 *
 * <p>The API of this class is designed to make it easy to achieve the following properties
 *
 * <ul>
 *   <li>Multiple events for the same listener are never dispatched concurrently.
 *   <li>Events for the different listeners are dispatched concurrently.
 *   <li>All events for a given listener dispatch on the provided executor.

    cancelLatch.await()

    val events = eventRecorder.eventSequence.filter { isConnectionEvent(it) }.map { it.name }
    eventRecorder.clearAllEvents()

    assertThat(events).startsWith("CallStart", "ConnectStart", "ConnectEnd", "ConnectionAcquired")
    if (cancelMode == CANCEL) {
      assertThat(events).contains("Canceled")
    } else {
      assertThat(events).doesNotContain("Canceled")
    }

        }
        canceled -> {
          events += "plan $id TCP connect canceled"
          ConnectResult(this, nextPlan = connectTcpNextPlan, throwable = IOException("canceled"))
        }
        connectTcpNextPlan != null -> {
          events += "plan $id needs follow-up"
          ConnectResult(this, nextPlan = connectTcpNextPlan)
        }
        else -> {
          events += "plan $id TCP connected"

 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present
 * for a call. In future releases of OkHttp these events may also occur concurrently to permit

  }

  /** Expose this recorder as a frame callback and shim in "ping" events.  */
  fun asFrameCallback() =
    object : WebSocketReader.FrameCallback {
      override fun onReadMessage(text: String) {
        events.add(Message(string = text))
      }

      override fun onReadMessage(bytes: ByteString) {
        events.add(Message(bytes = bytes))
      }

   *     can <i>usually</i> still preserve behavior by passing an explicit {@code null} cause. Note,
   *     however, that passing an explicit {@code null} cause prevents anyone from calling {@link
   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**