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

        then:
        1 * listenerManager.addListener({ it instanceof DaemonExpirationListener }) >> { DaemonExpirationListener listener ->
            daemonExpirationListener = listener
        }
        1 * listenerManager.addListener({ it instanceof BuildListener }) >> { BuildListener listener ->
            buildListener = listener
        }

        when:
        buildListener.buildFinished(Stub(BuildResult))

        then:

  hostnames:
    - "bar.com"
    - "*.example.com" # request matching is prevented by the isolation wildcard-example-com listener
    - "*.foo.example.com" # request matching is prevented by the isolation wildcard-foo-example-com listener
    - "abc.foo.example.com" # request matching is prevented by the isolation of abc-foo-example-com listener
  rules:
    - matches:
        - path:
            type: PathPrefix
            value: /empty-hostname

import org.gradle.tooling.internal.protocol.PhasedActionResult;
import org.gradle.tooling.internal.protocol.PhasedActionResultListener;

import java.util.ArrayList;
import java.util.List;

/**
 * Listener that will collect failures from the delegate listener and rethrow them in the right moment of the build.
 */
public class FailsafePhasedActionResultListener implements PhasedActionResultListener {
    private final PhasedActionResultListener delegate;

)

// Listener filter names
const (
	// OriginalDestination listener filter
	OriginalDestination = "envoy.filters.listener.original_dst"
	// ProxyProtocol listener filter
	ProxyProtocol = "envoy.filters.listener.proxy_protocol"
	// TLSInspector listener filter
	TLSInspector = "envoy.filters.listener.tls_inspector" // nolint:golint,revive
	// HTTPInspector listener filter

    /**
     * Executes the given action against the given listener collecting any new listener registrations in a separate
     * {@link ProjectEvaluationListener} instance which is returned at the end if not empty.
     *
     * @param listener the current listener
     * @param action the listener action

     * @see org.gradle.api.invocation.GradleLifecycle#afterProject(IsolatedAction)
     */
    void afterProject(IsolatedAction<? super Project> action);

    /**
     * Returns an isolated listener for the registered actions, if any. The listener makes it impossible for
     * the actions to carry any shared mutable state across projects and can be safely executed in parallel.
     */
    @Nullable

        }

        then: "build progress events must be forwarded to the attached listeners"
        events.assertIsABuild()
    }

    def "stops dispatching events to progress listeners when a listener fails and continues with build"() {
        given:
        goodCode()

        when: "launching a build"
        List<ProgressEvent> resultsOfFirstListener = []

            includeGroups == source.includeGroups
            excludeGroups == source.excludeGroups
            configFailurePolicy == source.configFailurePolicy
            listeners == source.listeners
            parallel == source.parallel
            threadCount == source.threadCount
            suiteThreadPoolSize.get() == source.suiteThreadPoolSize.get()

    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, TimeUnit.SECONDS));
    assertTrue(task.isDone());