holders.remove(holder);
        }
    }

    @Override
    public void addListener(JvmMemoryStatusListener listener) {
        listenerManager.addListener(listener);
    }

    @Override
    public void addListener(OsMemoryStatusListener listener) {
        listenerManager.addListener(listener);
    }

    @Override
    public void removeListener(JvmMemoryStatusListener listener) {

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

@ServiceScope(Scope.Global.class)
public interface MemoryManager {

    void addListener(JvmMemoryStatusListener listener);

    void addListener(OsMemoryStatusListener listener);

    void removeListener(JvmMemoryStatusListener listener);

    void removeListener(OsMemoryStatusListener listener);

    /**

                inputs.property('p', project)
                doLast { t -> t.project }
            }
        """
        buildFile << """
            tasks.register("broken") {
                gradle.addListener(new BuildAdapter())
                inputs.property('p', project).optional(true)
                doLast { }
            }
            tasks.register("ok") {
                doLast { }
            }
        """

    }

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

        given:
        listenerManager.addListener(listener)

        when:
        state.run(action)

        then:
        1 * action.apply(_)
        0 * actionExecutor._
        0 * listener._
    }

                DefaultBuildOperationAncestryTracker tracker = new DefaultBuildOperationAncestryTracker();
                listenerManager.addListener(tracker);
                return tracker;
            }
        });
    }

    }

    void configure(ServiceRegistration serviceRegistration, ListenerManager listenerManager, TestListenerBuildOperationAdapter testListenerBuildOperationAdapter) {
        listenerManager.addListener(testListenerBuildOperationAdapter);
    }

        BuildFlowScope::class.java,
        flowScheduler,
        flowProviders,
        flowParametersInstantiator,
        instantiatorFactory
    ).also {
        listenerManager.addListener(it)
    }

    @Provides
    fun createFlowScheduler(
        instantiatorFactory: InstantiatorFactory,
        services: ServiceRegistry,
    ): FlowScheduler = FlowScheduler(
        instantiatorFactory,

        registration.add(
            GradleUserHomeCleanupService.class,
            gradleUserHomeCleanupService
        );

        listenerManager.addListener(new BuildSessionLifecycleListener() {
            @Override
            public void beforeComplete() {
                if (cacheConfigurations.getCleanupFrequency().get().shouldCleanupOnEndOfSession()) {

   *
   * <p>When selecting an executor, note that {@code directExecutor} is dangerous in some cases. See
   * the discussion in the {@link ListenableFuture#addListener ListenableFuture.addListener}
   * documentation.
   */
  public void add(Runnable runnable, Executor executor) {
    // Fail fast on a null. We throw NPE here because the contract of Executor states that it throws

		),
	}
	if err := ret.loadCertKeyPair(); err != nil {
		return nil, err
	}

	return ret, nil
}

// AddListener adds a listener to be notified when the serving cert content changes.
func (c *DynamicCertKeyPairContent) AddListener(listener Listener) {
	c.listeners = append(c.listeners, listener)
}

// loadCertKeyPair determines the next set of content for the file.