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

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

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

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

        then:
        assertNoRunningDaemons()
    }

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

            }
            start { succeeds("c") }
            handle.waitForAllPendingCalls()
            handle.release("a")
            handle.waitForAllPendingCalls()
            handle.releaseAll()
            handle.waitForAllPendingCalls()
            handle.releaseAll()
            handle.waitForAllPendingCalls()
        }
        server.stop()

        then:
        noExceptionThrown()

        def build = executer.withTasks("resolve").start()

        metadataRequests.waitForAllPendingCalls()
        metadataRequests.release(2)

        metadataRequests.waitForAllPendingCalls()
        metadataRequests.release(2)

        requests.waitForAllPendingCalls()
        requests.release(2)

        requests.waitForAllPendingCalls()
        requests.release(2)

        build.waitForFinish()
    }

        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"

                }
            }
        """
        def block = server.expectAndBlock("block")
        def build = executer.withTasks("block", "--info").start()
        block.waitForAllPendingCalls()
        toolingApi.daemons.daemon.assertBusy()

        when:
        withConnection { connection ->
            connection.notifyDaemonsAboutChangedPaths(toPaths(changedPaths))
        }

            def build = action.build()
            build.withCancellationToken(cancel.token())
            collectOutputs(build)
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

        then:

        def handleA = server.expectAndBlock("handle:a")
        server.expect("handle:b")
        server.expect("serviceClosed")

        def build = executer.withTasks("b").start()

        handleA.waitForAllPendingCalls()
        // Increase the chance of the test to detect a broken implementation that doesn't wait for events to be processed before closing the service.
        sleep(1000)
        handleA.releaseAll()

        condition.signalAll();
    }


    @Override
    public void waitForAllPendingCalls() {
        waitForAllPendingCalls(BlockingHttpServer.FailureTracker.NO_FAILURE_TRACKER);
    }

    @Override
    public void waitForAllPendingCalls(BlockingHttpServer.FailureTracker failureTracker) {
        lock.lock();
        try {
            previous.assertCanWait();