private final Collection<MojoExecutionListener> listeners;

    CompoundMojoExecutionListener(Collection<MojoExecutionListener> listeners) {
        this.listeners = listeners; // NB this is live injected collection
    }

    public void beforeMojoExecution(MojoExecutionEvent event) throws MojoExecutionException {
        for (MojoExecutionListener listener : listeners) {
            listener.beforeMojoExecution(event);
        }
    }

        for (ProjectExecutionListener listener : listeners) {
            listener.afterProjectExecutionFailure(event);
        }
    }

    public void addProjectExecutionListener(ProjectExecutionListener listener) {
        this.listeners.add(listener);
    }

    public void removeProjectExecutionListener(ProjectExecutionListener listener) {
        this.listeners.remove(listener);
    }

     * T, the listener will be unregistered with it if <code>(listener instanceof T)</code> returns true.
     *
     * <p>When this method returns, the listener will not be in use and will not receive any further events.
     *
     * @param listener the listener to remove.
     */
    void removeListener(Object listener);

    /**
     * Allows a client to query if any listeners of a particular type are currently registered.

		p.DiscoverIPMode()
		listeners := buildOutboundListeners(t, p, nil, nil, services...)
		if len(listeners) != 1 {
			t.Fatalf("expected %d listeners, found %d", 1, len(listeners))
		}
		if p.IsDualStack() {
			if len(listeners[0].AdditionalAddresses) != 1 {
				t.Fatalf("expected %d additional addresses, found %d", 1, len(listeners[0].AdditionalAddresses))
			}

			}
		}
		addr := l.Addr()
		hosts = append(hosts, "http://"+addr.String())
		listeners = append(listeners, l)
	}
	return
}

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

        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.

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

        for (MojoExecutionListener listener : listeners) {
            listener.afterMojoExecutionSuccess(event);
        }
    }

    public void afterExecutionFailure(MojoExecutionEvent event) {
        for (MojoExecutionListener listener : listeners) {
            listener.afterExecutionFailure(event);
        }
    }

    public void addMojoExecutionListener(MojoExecutionListener listener) {
        this.listeners.add(listener);

		// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
		l.ActiveState.Listener.TypeUrl = v3.ListenerType
		err := l.ActiveState.Listener.UnmarshalTo(listenerTyped)
		if err != nil {
			return
		}
		listeners = append(listeners, listenerTyped)
	}
	Print(writer, listeners)