// 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());

        };

        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

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

        // 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());

    }

    /**
     * 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
     */

                WitnessNotificationListener listener = listeners.get(entry.getKey());
                if (listener != null) {
                    try {
                        listener.onWitnessNotification(notification);
                    } catch (Exception e) {
                        log.error("Error in witness notification listener", e);
                    }
                }
            }

      return delegate;
    }

    @Override
    public void addListener(Runnable listener, Executor exec) {
      executionList.add(listener, exec);

      // When a listener is first added, we run a task that will wait for the delegate to finish,
      // and when it is done will run the listeners.
      if (hasListeners.compareAndSet(false, true)) {
        if (delegate.isDone()) {

    RecordingListener listener = new RecordingListener();
    manager.addListener(listener, directExecutor());
    manager.startAsync().awaitHealthy();
    assertTrue(manager.isHealthy());
    assertTrue(listener.healthyCalled);
    assertFalse(listener.stoppedCalled);
    assertTrue(listener.failedServices.isEmpty());
    manager.stopAsync().awaitStopped();

    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());
    assertTrue(listenerLatch.await(5, SECONDS));
    assertTrue(task.isDone());
    assertFalse(task.isCancelled());