public List<ResolutionListener> getListeners() {
        return listeners;
    }

    public ArtifactResolutionRequest setListeners(List<ResolutionListener> listeners) {
        this.listeners = listeners;

        return this;
    }

    public ArtifactResolutionRequest addListener(ResolutionListener listener) {
        listeners.add(listener);

        return this;
    }

    }

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

        return updateScope;
    }

    private void fireEvent(int event, List<ResolutionListener> listeners, ResolutionNode node) {
        fireEvent(event, listeners, node, null);
    }

    private void fireEvent(int event, List<ResolutionListener> listeners, ResolutionNode node, Artifact replacement) {
        fireEvent(event, listeners, node, replacement, null);
    }

    private void fireEvent(
            int event,

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

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

                // won't happen
            }
        }

        if (listeners == null) {
            listeners = new ArrayList<>();

            if (logger.isDebugEnabled()) {
                listeners.add(new DebugResolutionListener(logger));
            }

            listeners.add(new WarningResolutionListener(logger));
        }

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

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

    exec.shutdown();
    exec.awaitTermination(100, MILLISECONDS);
  }

  /**
   * Tests that all listeners complete, even if they were added before or after the future was
   * finishing. Also acts as a concurrency test to make sure the locking is done correctly when a
   * future is finishing so that no listeners can be lost.
   */
  public void testAllListenersCompleteSuccessfully()

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