queue.enqueue(incrementingEvent(counters, listener1, 1));
    queue.enqueue(incrementingEvent(counters, listener1, 2));

    Object listener2 = new Object();
    queue.addListener(listener2, directExecutor());
    queue.enqueue(incrementingEvent(counters, multiset(listener1, 3, listener2, 1)));
    queue.enqueue(incrementingEvent(counters, multiset(listener1, 4, listener2, 2)));
    assertEquals(0, counters.size());
    queue.dispatch();

    queue.enqueue(incrementingEvent(counters, listener1, 1));
    queue.enqueue(incrementingEvent(counters, listener1, 2));

    Object listener2 = new Object();
    queue.addListener(listener2, directExecutor());
    queue.enqueue(incrementingEvent(counters, multiset(listener1, 3, listener2, 1)));
    queue.enqueue(incrementingEvent(counters, multiset(listener1, 4, listener2, 2)));
    assertEquals(0, counters.size());
    queue.dispatch();

        };

        ShutdownListener listener2 = new ShutdownListener() {
            @Override
            public void onShutdown() {
                callCount.addAndGet(10);
            }
        };

        // Add first listener
        jobExecutor.addShutdownListener(listener1);
        assertEquals(listener1, jobExecutor.shutdownListener);

        // Replace with second listener

    }

    /**
     * Add a listener for circuit breaker events
     *
     * @param listener the listener to add
     */
    public void addListener(CircuitBreakerListener listener) {
        if (listener != null) {
            listeners.add(listener);
        }
    }

    /**
     * Remove a listener
     *
     * @param listener the listener to remove
     */

        // Add second listener (should replace first)
        TestShutdownListener listener2 = new TestShutdownListener();
        scriptExecutor.addShutdownListener(listener2);

        // Call shutdown
        scriptExecutor.shutdown();

        // Verify only second listener was called
        assertFalse(listener1.wasShutdownCalled());
        assertTrue(listener2.wasShutdownCalled());

    void enqueueStoppedEvent() {
      listeners.enqueue(STOPPED_EVENT);
    }

    void enqueueHealthyEvent() {
      listeners.enqueue(HEALTHY_EVENT);
    }

    void enqueueFailedEvent(Service service) {
      listeners.enqueue(
          new ListenerCallQueue.Event<Listener>() {
            @Override
            public void call(Listener listener) {
              listener.failure(service);
            }

        // Test with listener1
        factory.setOnDestroyListener(listener1);
        assertEquals(listener1, factory.getOnDestroyListener());
        factory.destroyObject(pooledObject);
        assertEquals(1, events.size());
        assertEquals("listener1", events.get(0));

        // Switch to listener2
        factory.setOnDestroyListener(listener2);
        assertEquals(listener2, factory.getOnDestroyListener());

        .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(

   */
  public void addListener(L listener, Executor executor) {
    checkNotNull(listener, "listener");
    checkNotNull(executor, "executor");
    listeners.add(new PerListenerQueue<>(listener, executor));
  }

  /**
   * Enqueues an event to be run on currently known listeners.
   *
   * <p>The {@code toString} method of the Event itself will be used to describe the event in the
   * case of an error.