*/
    def newMemoryManager(OsMemoryInfo memoryInfo) {
        def listenerManager = Mock(ListenerManager) {
            1 * addListener(_) >> { args -> osMemoryStatusListener = args[0] }
        }
        def memoryManager = new DefaultMemoryManager(memoryInfo, jvmMemoryInfo, listenerManager, Stub(ExecutorFactory), 0.25, false)
        osMemoryStatusListener.onOsMemoryStatus(memoryInfo.getOsSnapshot())

import org.gradle.internal.event.ListenerManager;

import java.io.File;

public class DefaultScriptFileResolverListeners implements ScriptFileResolvedListener, ScriptFileResolverListeners {

    private final AnonymousListenerBroadcast<ScriptFileResolvedListener> broadcast;

    public DefaultScriptFileResolverListeners(ListenerManager listenerManager) {

        DefaultClassLoaderCache cache = new DefaultClassLoaderCache(classLoaderFactory, classpathHasher);
        listenerManager.addListener(cache);
        return cache;
    }

    @Provides
    ClassLoaderScopeRegistryListenerManager createClassLoaderScopeRegistryListenerManager(ListenerManager listenerManager) {

        Deleter deleter,
        GradleUserHomeDirProvider gradleUserHomeDirProvider,
        BuildOperationRunner buildOperationRunner,
        CacheConfigurationsInternal cacheConfigurations,
        ListenerManager listenerManager,
        CacheFactory cacheFactory
    ) {
        UsedGradleVersions usedGradleVersions = new UsedGradleVersionsFromGradleUserHomeCaches(cacheBuilderFactory);

        @Provides
        BuildSessionActionExecutor createActionExecutor(
            BuildEventListenerFactory listenerFactory,
            ExecutorFactory executorFactory,
            ListenerManager listenerManager,
            BuildOperationListenerManager buildOperationListenerManager,
            BuildOperationRunner buildOperationRunner,
            WorkInputListeners workListeners,

    private final DaemonExpirationListener listenerBroadcast;

    public DaemonHealthCheck(DaemonExpirationStrategy strategy, ListenerManager listenerManager) {
        this.strategy = strategy;
        this.listenerBroadcast = listenerManager.getBroadcaster(DaemonExpirationListener.class);
    }

    public void executeHealthCheck() {
        DaemonExpirationResult result = strategy.checkExpiration();

 */

package org.gradle.internal.buildoption

import org.gradle.internal.event.ListenerManager
import spock.lang.Specification

class DefaultFeatureFlagsTest extends Specification {
    def sysProperties = [:]
    def featureFlagListener = Mock(FeatureFlagListener)
    def listenerManager = Stub(ListenerManager) {
        getBroadcaster(FeatureFlagListener) >> featureFlagListener
    }

        services.add(listenerManager)
        state = new BuildTreeState(buildInvocationScopeId, services, Stub(BuildTreeModelControllerServices.Supplier))
    }

    def "does nothing when function does nothing"() {
        def listener = Mock(BuildTreeLifecycleListener)
        def action = Mock(Function)

        given:
        listenerManager.addListener(listener)

        when:

        final BuildCommencedTimeProvider timeProvider,
        SuppliedComponentMetadataSerializer suppliedComponentMetadataSerializer,
        ListenerManager listenerManager
    ) {
        if (cacheDecoratorFactory instanceof CleaningInMemoryCacheDecoratorFactory) {
            listenerManager.addListener(new BuildModelLifecycleListener() {
                @Override

    private final ListenerManager listenerManager;
    private final GradleUserHomeScopeServiceRegistry userHomeDirServiceRegistry;
    private final CrossBuildSessionState crossBuildSessionState;
    private final BuildCancellationToken buildCancellationToken;

    public BuildStateFactory(
        BuildTreeState buildTreeState,
        ListenerManager listenerManager,