}
}
"""

        when:
        def blockingHandler = server.expectAndBlock(UNBLOCK)
        def build = executer.withTasks("block").start()
        blockingHandler.waitForAllPendingCalls()
        daemons.daemon.assertBusy()
        executer.withArguments("--stop").run()
        def failure = build.waitForFailure()

        then:
        stopsSingleDaemon()

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

        // Start build 2 then wait until it has run both 'a' and 'b'.
        def currentExecuter = version(current)
        currentExecuter.withArgument("-Penable-block2")
        currentExecuter.withTasks("c")
        def build2 = currentExecuter.start()
        block2.waitForAllPendingCalls()

        // Finish up build 1 and 2

        def testExecution = server.expectConcurrentAndBlock(2, SERVER_RESOURCE_1, SERVER_RESOURCE_2)

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

        then:
        ConcurrentTestUtil.poll {
            containsTestExecutionWorkInProgressLine(gradleHandle, ':test', testClass1.renderedClassName)

            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')