public CompoundProjectExecutionListener(Collection<ProjectExecutionListener> listeners) {
        this.listeners = listeners; // NB this is live injected collection
    }

    @Override
    public void beforeProjectExecution(ProjectExecutionEvent event) throws LifecycleExecutionException {
        for (ProjectExecutionListener listener : listeners) {

	}

	if len(listeners) == 0 {
		// No listeners initialized, no need to continue
		return listener, listenErrs
	}
	listeners = slices.Clip(listeners)

	ctx, cancel := context.WithCancel(ctx)
	listener = &httpListener{
		listeners:   listeners,
		acceptCh:    make(chan acceptResult, len(listeners)),
		opts:        opts,
		ctxDoneCh:   ctx.Done(),
		ctxCanceler: cancel,
	}

        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.

  final @Nullable Listener listeners() {
    return listeners;
  }

  final void releaseWaiters() {}

  AbstractFutureState() {}

  static final Object NULL = new Object();

  static final LazyLogger log = new LazyLogger(AbstractFuture.class);

  static final boolean GENERATE_CANCELLATION_CAUSES = false;

  private volatile @Nullable Object value;

  private volatile @Nullable Listener listeners;

}

func startHTTPServer(listener net.Listener, handler http.Handler) (server *httptest.Server) {
	server = httptest.NewUnstartedServer(handler)
	server.Config.Addr = listener.Addr().String()
	server.Listener = listener
	server.Start()
	return server
}

func dummyRequestValidate(r *http.Request) error {
	return nil
}

func dummyTokenValidate(token string) error {
	if token == "debug" {
		return nil

   * MoreExecutors#directExecutor}. Otherwise, avoid it: See the warnings on the docs for {@code
   * directExecutor}.
   *
   * <p>This is the most general listener interface. For common operations performed using
   * listeners, see {@link Futures}. For a simplified but general listener interface, see {@link
   * Futures#addCallback addCallback()}.
   *

 * instance contains a list of listeners, each with an associated {@code Executor}, and guarantees
 * that every {@code Runnable} that is {@linkplain #add added} will be executed after {@link
 * #execute()} is called. Any {@code Runnable} added after the call to {@code execute} is still
 * guaranteed to execute. There is no guarantee, however, that listeners will be executed in the

    if (!isDone()) {
      Listener oldHead = listeners();
      if (oldHead != Listener.TOMBSTONE) {
        Listener newNode = new Listener(listener, executor);
        do {
          newNode.next = oldHead;
          if (casListeners(oldHead, newNode)) {
            return;
          }
          oldHead = listeners(); // re-read
        } while (oldHead != Listener.TOMBSTONE);
      }
    }

   * @since 13.0
   */
  @Override
  public final void addListener(Listener listener, Executor executor) {
    listeners.addListener(listener, executor);
  }

  @Override
  public String toString() {
    return getClass().getSimpleName() + " [" + state() + "]";
  }

  /**
   * Attempts to execute all the listeners in {@link #listeners} while not holding the {@link
   * #monitor}.
   */