she first saw the White Rabbit.  She was a little nervous about
it just at first, the two creatures got so close to her, one on
each side, and opened their eyes and mouths so VERY wide, but she
gained courage as she went on.  Her listeners were perfectly
quiet till she got to the part about her repeating `YOU ARE OLD,
FATHER WILLIAM,' to the Caterpillar, and the words all coming
different, and then the Mock Turtle drew a long breath, and said

    val sanUrl = url.newBuilder().host("san.com").build()
    val latch1 = CountDownLatch(1)
    val latch2 = CountDownLatch(1)
    val latch3 = CountDownLatch(1)
    val latch4 = CountDownLatch(1)
    val listener1: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          try {

        .build(),
    )
    val request = Request.Builder().url(server.url("/")).build()
    val response = client.newCall(request).execute()
    response.processEventSource(listener)
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
  }

  @Test
  fun cancelShortCircuits() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """

  private val call: Call?,
  private val request: Request,
  private val listener: EventSourceListener,
) : EventSource,
  ServerSentEventReader.Callback,
  Callback {
  constructor(call: Call, listener: EventSourceListener) : this(call, call.request(), listener)

  constructor(response: Response, listener: EventSourceListener) : this(null, response.request, listener)

  @Volatile private var canceled = false

  override fun onResponse(

    listener.takeEvent(ResponseHeadersEnd::class.java, 0L)
    listener.takeEvent(FollowUpDecision::class.java, 0L)
    listener.takeEvent(ResponseBodyStart::class.java, responseBodyStartDelay)
    listener.takeEvent(ResponseBodyEnd::class.java, responseBodyEndDelay)
    listener.takeEvent(CallEvent.ConnectionReleased::class.java, 0L)

    CountingRunnable listener = new CountingRunnable();

    future.addListener(listener, directExecutor());
    listener.assertNotRun();

    future.set(1);
    listener.assertRun();
  }

  public void testListenLaterFailed() {
    CountingRunnable listener = new CountingRunnable();

    future.addListener(listener, directExecutor());
    listener.assertNotRun();

    assertNull(segment.refresh(key, hash, identityLoader(), false));
  }

  // Removal listener tests

  public void testRemovalListener_explicit() {
    QueuingRemovalListener<Object, Object> listener = queuingRemovalListener();
    LocalCache<Object, Object> map = makeLocalCache(createCacheBuilder().removalListener(listener));
    assertTrue(listener.isEmpty());

    Object one = new Object();
    Object two = new Object();

        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val source = newEventSource()
    assertThat(source.request().url.encodedPath).isEqualTo("/")
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
  }

  @RetryingTest(5)
  fun cancelInEventShortCircuits() {
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          """

     * This method notifies the shutdown listener to perform cleanup operations.
     */
    public void shutdown() {
        shutdownListener.onShutdown();
    }

    /**
     * Adds a shutdown listener to be notified when the executor is shutting down.
     *
     * @param listener the shutdown listener to add
     */
    public void addShutdownListener(final ShutdownListener listener) {
        shutdownListener = listener;

  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * returns the expected data.
   *
   * @throws Throwable if the listener isn't called or if it resulted in a throwable or if the
   *     result doesn't match the expected value.
   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.