when:
        connection.run(action)

        then:
        1 * loggingProvider.listenerManager >> listenerManager
        1 * loggingProvider.progressLoggerFactory >> progressLoggerFactory
        1 * listenerManager.addListener(!null)
        1 * progressLoggerFactory.newOperation(ProgressLoggingConsumerActionExecutor.class) >> progressLogger
        1 * progressLogger.setDescription('Build')

    private final BuildSessionActionExecutor delegate;
    private final ListenerManager listenerManager;
    private final BuildOperationListenerManager buildOperationListenerManager;
    private final List<Object> listeners = new ArrayList<>();
    private final BuildEventListenerFactory factory;

    public SubscribableBuildActionExecutor(ListenerManager listenerManager,

    def options = Stub(DaemonForkOptions)
    def starter = Stub(WorkerDaemonStarter)
    def listenerManager = Stub(ListenerManager)
    def loggingManager = Stub(LoggingManagerInternal)
    def memoryManager = Mock(MemoryManager)

    @Subject
        manager = new WorkerDaemonClientsManager(starter, listenerManager, loggingManager, memoryManager, new MBeanOsMemoryInfo(new DefaultMBeanAttributeProvider()))

    private void addLowMemoryDaemonExpirationStrategyWhenSupported(Daemon daemon, ImmutableList.Builder<DaemonExpirationStrategy> strategies, ListenerManager listenerManager) {
        final LowMemoryDaemonExpirationStrategy lowMemoryDaemonExpirationStrategy = new LowMemoryDaemonExpirationStrategy(0.05);
        listenerManager.addListener(lowMemoryDaemonExpirationStrategy);
        strategies.add(new AllDaemonExpirationStrategy(ImmutableList.of(

 */
@ThreadSafe
public class DefaultConfigurationFactory {

    private final Instantiator instantiator;
    private final ConfigurationResolver resolver;
    private final ListenerManager listenerManager;
    private final DependencyMetaDataProvider metaDataProvider;
    private final ComponentIdentifierFactory componentIdentifierFactory;
    private final DependencyLockingProvider dependencyLockingProvider;

import org.gradle.internal.event.ListenerManager;

public class PendingChangesManager {
    private final ListenerManager listenerManager;

    public PendingChangesManager(ListenerManager listenerManager) {
        this.listenerManager = listenerManager;
    }

    public void addListener(PendingChangesListener listener) {
        listenerManager.addListener(listener);
    }

        }

        GradleInternal gradle = buildScopeServices.get(GradleInternal.class);
        ListenerManager listenerManager = buildScopeServices.get(ListenerManager.class);

        BuildModelController buildModelController = buildScopeServices.get(BuildModelController.class);
        InternalProblems problems = buildScopeServices.get(InternalProblems.class);

import org.gradle.internal.event.ListenerManager
import org.gradle.kotlin.dsl.support.disposeKotlinCompilerContext


/**
 * Disposes Kotlin compiler environment once all scripts are compiled.
 */
internal
class KotlinCompilerContextDisposer(
    private val listenerManager: ListenerManager
) : InternalBuildAdapter(), Stoppable {

    init {
        listenerManager.addListener(this)
    }

    public DefaultFileContentCacheFactory(ListenerManager listenerManager, FileSystemAccess fileSystemAccess, ScopedCacheBuilderFactory cacheBuilderFactory, InMemoryCacheDecoratorFactory inMemoryCacheDecoratorFactory) {
        this.listenerManager = listenerManager;
        this.fileSystemAccess = fileSystemAccess;
        this.inMemoryCacheDecoratorFactory = inMemoryCacheDecoratorFactory;

    private final ClassLoaderHierarchyHasher classLoaderHierarchyHasher;
    private final ExecutionEngine executionEngine;
    private final InputFingerprinter inputFingerprinter;
    private final ListenerManager listenerManager;
    private final ReservedFileSystemLocationRegistry reservedFileSystemLocationRegistry;
    private final FileCollectionFactory fileCollectionFactory;
    private final TaskDependencyFactory taskDependencyFactory;