public class DefaultFileChangeListeners implements FileChangeListeners {
    private final AnonymousListenerBroadcast<FileChangeListener> broadcaster;

    public DefaultFileChangeListeners(ListenerManager listenerManager) {
        this.broadcaster = listenerManager.createAnonymousBroadcaster(FileChangeListener.class);
    }

    @Override
    public void addListener(FileChangeListener listener) {
        broadcaster.add(listener);
    }

    @Override

    }

    @Provides
    TaskListenerInternal createTaskListenerInternal(ListenerManager listenerManager) {
        return listenerManager.getBroadcaster(TaskListenerInternal.class);
    }

    @Provides
    ListenerBroadcast<TaskExecutionGraphListener> createTaskExecutionGraphListenerBroadcast(ListenerManager listenerManager) {
        return listenerManager.createAnonymousBroadcaster(TaskExecutionGraphListener.class);
    }

    private final FileSystem fileSystem;
    private final FileResourceListener listener;

    public FileResourceConnector(FileSystem fileSystem, ListenerManager listenerManager) {
        this.fileSystem = fileSystem;
        this.listener = listenerManager.getBroadcaster(FileResourceListener.class);
    }

    @Override
    public ExternalResourceRepository withProgressLogging() {
        return this;
    }

/**
 * Augments the [DefaultEnvironment] to track access to properties files, environment variables and system properties.
 **/
class ConfigurationCacheEnvironment(
    private val listenerManager: ListenerManager
) : DefaultEnvironment() {

    @EventScope(Scope.Build::class)
    interface Listener {
        fun systemPropertiesPrefixedBy(prefix: String, snapshot: Map<String, String?>)

                classpathFingerprinter
            },
            fileCollectionFactory
        )

    @Provides
    fun createKotlinCompilerContextDisposer(listenerManager: ListenerManager) =
        KotlinCompilerContextDisposer(listenerManager)

    private
    val isKotlinScriptCompilationAvoidanceEnabled: Boolean
        get() = System.getProperty(KOTLIN_SCRIPT_COMPILATION_AVOIDANCE_ENABLED_PROPERTY, "true") == "true"

    private final ListenerManager listenerManager;
    private final BuildOperationListenerManager buildOperationListenerManager;
    private final Map<Provider<?>, AbstractListener<?>> subscriptions = new LinkedHashMap<>();
    private final ExecutorFactory executorFactory;

    public DefaultBuildEventsListenerRegistry(
        BuildEventListenerFactory factory,
        ListenerManager listenerManager,

     */
    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);