* of a given type receive events in the same order. Listeners can be added and removed at any time.
 */
@ServiceScope(Scope.Global.class)
public interface ListenerManager {
    /**
     * Adds a listener.  A single object can implement multiple interfaces, and all interfaces are registered by a

        then:
        1 * listenerManager.removeListener(daemonExpirationListener)
        1 * listenerManager.removeListener(buildListener)
    }

    def "should unregister daemon expiration listener on notification"() {
        given:
        def listenerManager = Mock(ListenerManager)
        def notifyAction = Mock(Action)

        when:
        services.add(ListenerManager, new DefaultListenerManager(Scope.BuildTree))

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Service ListenerManager with implementation DefaultListenerManager implements AnnotatedServiceLifecycleHandler but is not declared as a service of this type. This service is declared as having type ListenerManager.'
    }

    private final boolean singleRun;
    private final DaemonRegistry daemonRegistry;
    private final ListenerManager listenerManager;

    public DefaultDaemonScanInfo(final DaemonRunningStats stats, final long idleTimeout, boolean singleRun, final DaemonRegistry daemonRegistry, final ListenerManager listenerManager) {
        this.stats = stats;
        this.idleTimeout = idleTimeout;
        this.singleRun = singleRun;

    }

    private static class ThreadLoggingServices {
        final ListenerManager listenerManager;
        final ProgressLoggerFactory progressLoggerFactory;

        private ThreadLoggingServices(ListenerManager listenerManager, ProgressLoggerFactory progressLoggerFactory) {
            this.listenerManager = listenerManager;
            this.progressLoggerFactory = progressLoggerFactory;
        }
    }

        this(osMemoryInfo, jvmMemoryInfo, listenerManager, executorFactory, DEFAULT_MIN_FREE_MEMORY_PERCENTAGE, true);
    }

    @VisibleForTesting

    }

    @Provides
    protected DaemonHealthCheck createDaemonHealthCheck(ListenerManager listenerManager, HealthExpirationStrategy healthExpirationStrategy) {
        return new DaemonHealthCheck(healthExpirationStrategy, listenerManager);
    }

    @Provides
    protected DaemonRunningStats createDaemonRunningStats() {
        return new DaemonRunningStats();
    }

        }

        def runner = new SubscribableBuildActionExecutor(listenerManager, buildOperationListenerManager, factory, consumer, delegate)

        when:
        runner.execute(buildAction, buildSessionContext)

        then:
        1 * listenerManager.addListener(listener1)
        1 * listenerManager.addListener(listener2)
        1 * buildOperationListenerManager.addListener(listener1)

import org.gradle.internal.buildtree.BuildTreeLifecycleController;
import org.gradle.internal.event.ListenerManager;
import org.gradle.internal.invocation.BuildAction;
import org.gradle.internal.logging.text.StyledTextOutputFactory;

public class BuildOutcomeReportingBuildActionRunner implements BuildActionRunner {
    private final ListenerManager listenerManager;
    private final BuildActionRunner delegate;

            return new DefaultFileChangeListeners(listenerManager);
        }
    }

    @VisibleForTesting
    static class BuildSessionServices implements ServiceRegistrationProvider {

        @Provides
        FileSystemDefaultExcludesProvider createFileSystemDefaultExcludesProvider(ListenerManager listenerManager) {