instant.mutating1
                    thread.blockUntil.finished1
                }
                state1.applyToMutableState { p ->
                    assert state1.hasMutableState()
                    instant.mutating2
                    thread.blockUntil.finished2
                }
            }
            start {

        containsEvent(FINISHED, DefaultTestMethodDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest > testOut')
        containsEvent(FINISHED, DefaultTestClassDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest')
        containsEvent(FINISHED, DefaultTestSuiteDescriptor, 'TestSuite > LightTest')

            progress("2", id2),
            progress("3", id2),

            finished("3", id1),
            finished("2", id1),
            progress("1", id1),
            finished("1", id1),

            finished("3", id2),
            finished("2", id2),
            progress("1", id2),
            finished("1", id2)
        ]
    }

    BuildOperationListener recordingListener(String label) {

        broadcast.finished(d5, new OperationFinishEvent(-1, -1, null, null))
        broadcast.finished(d4, new OperationFinishEvent(-1, -1, null, null))

        broadcast.finished(d2, new OperationFinishEvent(-1, -1, null, null))
        broadcast.finished(d1, new OperationFinishEvent(-1, -1, null, null))

        then:
        1 * listener.started(_) >> { BuildOperationStartedNotification n ->

            gradle.buildFinished {
                println "root build finished"
                assert System.getProperty("buildsrc") == "done"
            }
        """

        when:
        run()

        then:
        output.indexOf("running tasks") < output.indexOf("buildSrc finished")
        output.indexOf("buildSrc finished") < output.indexOf("root build finished")
    }

        then:
        outputContains("build A finished")
        outputContains("build B finished")
        outputContains("build C finished")

        events(13)
        loggedOncePerBuild("buildListener.buildFinished failure=null", [':buildB'])
        loggedOncePerBuild("gradle.buildFinished failure=null", [':buildB'])

                return FINISHED
            }
        })

        then:
        disposition == expectedDisposition

        and:
        !lock1.lockedState
        !lock2.lockedState

        where:
        lock1Locked | lock2Locked | expectedDisposition
        true        | true        | FINISHED
        true        | false       | FINISHED
        false       | true        | FINISHED

    assert middleware_state["context_b"] == "finished b with a: started a"
    assert middleware_state["context_a"] == "finished a"
    assert middleware_state["bg"] == "not set"
    assert state["context_b"] == "finished b with a: started a"
    assert state["context_a"] == "finished a"
    assert state["bg"] == "bg set - b: finished b with a: started a - a: finished a"


def test_sync_raise_raises():

        0 * tracker1._
        0 * tracker2._
        0 * tracker3._

        when:
        generator.finished(operation, finishEvent)

        then:
        1 * tracker1.finished(operation, finishEvent)
        1 * tracker2.finished(operation, finishEvent)
        1 * tracker3.finished(operation, finishEvent)

        then:
        1 * tracker1.discardState(operation)

    private UserInput pending;
    private boolean finished;

    @Override
    public void startInput() {
        synchronized (lock) {
            pending = null;
            finished = false;
        }
    }

    @Override
    public void putInput(UserInput input) {
        synchronized (lock) {
            if (input == END_OF_INPUT) {
                finished = true;
                lock.notifyAll();