}

    def "models are streamed on build action cache hit"() {
        def listener1 = new TestStreamedValueListener()
        def listener2 = new TestStreamedValueListener()

        when:
        withIsolatedProjects()
        def model = runBuildAction(new ModelStreamingBuildAction()) {
            setStreamedValueListener(listener1)
        }

        then:
        fixture.assertStateStored {

    }

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

        TransferEvent transferSucceededEvent = event(session, resource, TransferEvent.EventType.SUCCEEDED);

        listener.transferInitiated(transferInitiatedEvent);
        listener.transferStarted(transferStartedEvent);
        listener.transferProgressed(transferProgressedEvent);
        listener.transferSucceeded(transferSucceededEvent);

        Thread.sleep(500); // to make sure queue is processed, cancellation applied

    }

    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._
    }

    def "fires events before and after build action is run"() {

    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) {

        """
    }

    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

    }

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