def builder = connection.model(GradleProject)
            builder.standardOutput = outInstance
            builder.standardError = errInstance
            builder.get(handler)
            handle.waitForAllPendingCalls()
            assert System.out.is(outInstance)
            assert System.err.is(errInstance)
            assert System.in.is(inInstance)
            handle.releaseAll()
            handler.result
        }

            def build = connection.newBuild()
            build.standardOutput = output
            build.forTasks("log")
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            ConcurrentTestUtil.poll {
                // Need to poll, as logging output is delivered asynchronously to client
                assert output.toString().contains(waitingMessage)
            }

        def done = server.expectAndBlock("b-done")
        def build = executer.withArguments("--parallel").withTasks("run").start()

        waiting.waitForAllPendingCalls()
        waiting.release("b-waiting")
        done.waitForAllPendingCalls()
        done.releaseAll()
        waiting.releaseAll()
        result = build.waitForFailure()

        then:

        def block = server.expectAndBlock("block")
        def build = executer.withTasks("block").start()
        block.waitForAllPendingCalls()

        daemons.daemon.assertBusy()
        executer.useOnlyRequestedJvmOpts()
        executer.withBuildJvmOpts('-Xmx128m')
        executer.run()

        when:

                }
            }
        """
        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 build = connection.newTestLauncher()
            build.withJvmTestClasses("Broken")
            build.withCancellationToken(cancel.token())
            build.run(resultHandler)
            sync.waitForAllPendingCalls(resultHandler)
            cancel.cancel()
            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        buildWasCancelled(resultHandler, 'Could not execute tests using')

        when:
        def gradleHandle = executer.withTasks('test', '--fail-fast').start()
        testExecution.waitForAllPendingCalls()

        then:
        testExecution.release(1)
        gradleHandle.waitForFailure()
        def result = new DefaultTestExecutionResult(testDirectory)

        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();