expect:
        childBuildScript.waitForAllPendingCalls()
        assertHasWorkInProgress(":child")
        childBuildScript.releaseAll()

        and:
        childABuildScript.waitForAllPendingCalls()
        assertHasWorkInProgress(":child:a")
        childABuildScript.releaseAll()

        and:
        rootBuildScript.waitForAllPendingCalls()
        assertHasWorkInProgress("root project")

        expect:
        settings.waitForAllPendingCalls()
        assertHasBuildPhase("0% INITIALIZING")
        settings.releaseAll()

        and:
        rootBuildScript.waitForAllPendingCalls()
        assertHasBuildPhase("0% CONFIGURING")
        rootBuildScript.releaseAll()

        and:
        bBuildScript.waitForAllPendingCalls()
        assertHasBuildPhase("40% CONFIGURING")

        def build1 = executer.start()
        block1.waitForAllPendingCalls()

        // Change content and start build 2 then wait until it has run task 'a'. Should see 'a' is not up-to-date
        inputFile.text = 'new content'
        executer.withTasks("block2")
        def build2 = executer.start()
        block2.waitForAllPendingCalls()

        // Finish up build 1
        block1.releaseAll()

        putJar.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {
            RichConsoleStyling.assertHasWorkInProgress(build, "> :publishMavenPublicationToMavenRepository > test-1.2.jar")
        }

        when:
        putJar.releaseAll()
        putJarSha.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {

        def testExecution = server.expectConcurrentAndBlock(DEFAULT_MAX_WORKERS, FAILED_RESOURCE, OTHER_RESOURCE)

        when:
        def gradleHandle = executer.withTasks(taskList).start()
        testExecution.waitForAllPendingCalls()

        then:
        testExecution.release(FAILED_RESOURCE)
        testExecution.release(OTHER_RESOURCE)
        gradleHandle.waitForFailure()

            def build = connection.newBuild()
            build.forTasks(':sub:broken')
            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        buildWasCancelled(resultHandler)
    }

        def gradle = executer.start()

        then:
        handler.waitForAllPendingCalls()

        when:
        handler.release(1)

        then:
        handler.waitForAllPendingCalls()

        when:
        handler.release(2)

        then:
        handler.waitForAllPendingCalls()

        when:
        handler.release(3)

        then:

        def build = connection.newBuild()
        build.forTasks('hang')
        build.run(resultHandler)
        sync.waitForAllPendingCalls(resultHandler)
        connector.disconnect()
        resultHandler.finished()

        then:
        assertNoRunningDaemons()
    }

    @Timeout(30)
    @TargetGradleVersion(">=6.8")

        def build1 = executer.withTasks("redThings", "block1", "blueThings").start()
        block1.waitForAllPendingCalls()

        // Block until second build has produced blue things
        def build2 = executer.withTasks("redThings", "blueThings", "block2").start()
        block2.waitForAllPendingCalls()

        // Finish up first build while second build is still running
        block1.releaseAll()

        when:
        def gradle = executer.withTasks("runWork").start()

        then:
        started.waitForAllPendingCalls()

        then:
        started.release("submitted")
        started.release("item1")
        started.release("item2")

        then:
        finished.waitForAllPendingCalls()

        then:
        finished.releaseAll()
        started.release("item3")

        then: