private final OutputEventListener listener;
    private final Map<OperationIdentifier, Operation> operations = new LinkedHashMap<OperationIdentifier, Operation>();

    public ProgressLogEventGenerator(OutputEventListener listener) {
        this.listener = listener;
    }

    @Override
    public void onOutput(OutputEvent event) {

            unsupportedReason
        );
    }

    @Override
    public void notify(BuildScanEndOfBuildNotifier.Listener listener) {
        if (this.listener != null) {
            throw new IllegalStateException("listener already set to " + this.listener);
        }
        this.listener = listener;
    }

    private boolean isPluginAwareOfUnsupported(VersionNumber pluginVersion) {

        """
    }

    def runTask() {
        def listener = new ProblemProgressListener()
        withConnection { connection ->
            connection.newBuild().forTasks('reportProblem')
                .addProgressListener(listener)
                .run()
        }
        return listener.problems.collect { it.descriptor }
    }


    @TargetGradleVersion("=8.3")

            withUniqueProblems(
                "Build file 'build.gradle': line 2: registration of listener on 'Gradle.buildFinished' is unsupported")
            withProblemsWithStackTraceCount(1)
        }

        and:
        verifyAll(receivedProblem(0)) {
            fqid == REGISTRATION_UNSUPPORTED
            contextualLabel == "registration of listener on 'Gradle.buildFinished' is unsupported"
            definition.severity == Severity.WARNING

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

    void addListener(JvmMemoryStatusListener listener);

    void addListener(OsMemoryStatusListener listener);

    void removeListener(JvmMemoryStatusListener listener);

    void removeListener(OsMemoryStatusListener listener);

    /**
     * Register a memory resource holder.
     *
     * @param holder The memory resource holder to register

    }

    def "end of build listener may fail with an exception"() {
        when:
        fails succeedingTaskName, "-Dbuild-listener-failure"

        then:
        plugin.assertEndOfBuildWithFailure(output, null)
        failure.assertHasDescription("broken")

        when:
        fails succeedingTaskName, "-Dbuild-listener-failure"

        then:

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

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

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

    @Override

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Attached to a listener interface to indicate that its events are stateful.
 *
 * <p>The listener infrastructure will ensure that a listener of this type will either receive all events, or no events.
 * Currently, this is done by disallowing the registration of a listener of this type once any events have been fired.
 *
 * @see Scope
 */

    private final OutputEventListener listener;

    private final ScheduledExecutorService executor;
    private final Clock clock;
    private final int throttleMs;
    private final Object lock = new Object();

    private final List<OutputEvent> queue = new ArrayList<OutputEvent>();

    public ThrottlingOutputEventListener(OutputEventListener listener, Clock clock) {

        Action<? super ValueSourceSpec<P>> configureAction
    );

    void addValueListener(ValueListener listener);

    void removeValueListener(ValueListener listener);

    void addComputationListener(ComputationListener listener);

    void removeComputationListener(ComputationListener listener);

    <T, P extends ValueSourceParameters> Provider<T> instantiateValueSourceProvider(