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

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

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

        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 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:

        file('src/main/java/Foo.java') << blockingFooClass
        def handler = blockingHttpServer.expectAndBlock("/block")

        when:
        startBuild("compileJava")

        then:
        handler.waitForAllPendingCalls()

        then:
        cancelBuild()

        then:
        daemons.daemon.becomesIdle()

        and:
        pidFile().exists()
        def pid1 = pidFile().text.strip() as long

        when:
        executer.withTestConsoleAttached()
        executer.withConsole(ConsoleOutput.Rich)
        def build = executer.withTasks("resolve").withArguments("--max-workers=2").start()
        metaData.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {
            outputContainsProgress(build,
                "> :resolve > Resolve dependencies of :compile",
                "> one-1.2.pom", "> two-1.2.pom"

        then:
        handler.waitForAllPendingCalls()
        handler.release(1)

        and:
        if (maxConcurrency - 1 > 0) {
            handler.waitForAllPendingCalls()
            handler.release(maxConcurrency - 1)
        }

        and:
        handler.waitForAllPendingCalls()
        handler.release(maxConcurrency)

        then:

        executer.withArgument("--info")
        def build1 = executer.start()
        block1.waitForAllPendingCalls()

        // Start build 2 then wait until it has run both 'a' and 'b'.
        executer.withTasks("a", "b", "block2")
        executer.withArgument("--info")
        def build2 = executer.start()
        block2.waitForAllPendingCalls()

        // Finish up build 1 and 2