execHandleBuilder.setErrorOutput(outputStream); // verbose output is written to stderr
        execHandleBuilder.setStandardOutput(new ByteArrayOutputStream());
        execHandleBuilder.build().start().waitForFinish().assertNormalExitValue();
    }

            BuildActionResult result = actionExecuter.execute(build.getAction(), build.getParameters(), buildRequestContext);
            execution.setResult(result);
        } finally {
            buildEventConsumer.waitForFinish();
            runningStats.buildFinished();
            LOGGER.debug(DaemonMessages.FINISHED_BUILD);
        }

        def stopExecutions = []
        5.times { idx ->
            stopExecutions << executer.withArguments("--stop").start()
        }
        stopExecutions.each { it.waitForFinish() }
        def out = executer.withArguments("--stop").run().output

        then:
        stopsSingleDaemon()
        out.contains(DaemonMessages.NO_DAEMONS_RUNNING)

        build.waitForFailure()
    }

            lastOutput = gradle.standardOutput
            assert newOutput.contains("beep...")
        }

        then:
        handler.releaseAll()

        then:
        gradle.waitForFinish()
    }

    def "log messages from a worker daemon are associated with the task that invokes them"() {
        def buildOperations = new BuildOperationsFixture(executer, temporaryFolder)

        when:
        toolingApi.close()

        then:
        toolingApi.daemons.daemon.assertBusy()

        when:
        sync.releaseAll()
        build.waitForFinish()

        then:
        toolingApi.daemons.daemon.stops()
    }

    def "shutdown ignores daemons that are no longer running"() {
        given:
        withConnection { connection ->

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

        result = build.waitForFinish()

        then: "build succeeds and only one listener service was created"

        outputContains("listener 1 created")
        outputDoesNotContain("listener 2 created")
    }

        handler.waitForAllPendingCalls()
        handler.release('/sync')
        Thread.sleep(1000)
        handler.release(module.pom.path)

        build.waitForFinish()
    }

    @Issue('https://github.com/gradle/gradle/issues/11247')
    @ToBeFixedForConfigurationCache(because = "task uses artifact query API")
    def 'respects repository content filter'() {
        given:

                "> one-1.2.jar > 1 KiB/2 KiB downloaded", "> two-1.2.jar > 1 KiB/2 KiB downloaded"
            )
        }

        getM1Jar.release()
        getM2Jar.release()
        build.waitForFinish()
    }

    void outputContainsProgress(GradleHandle build, String taskProgressLine, String... progressOutputLines) {
        def output = LogContent.of(build.standardOutput).ansiCharsToColorText().withNormalizedEol()

        def cacheAccess = simulateAnotherInitializationOfAlreadyInitializedWorkerClasspathCache()
        cacheAccess.open()
        block.releaseAll()
        build.waitForFinish()

        then:
        noExceptionThrown()

        cleanup:
        cacheAccess?.close()
    }

    /**

            }
        """.stripIndent()

        when:
        args("--debug")
        def gradle = executer.withTasks("runInWorker").start()

        then:
        gradle.waitForFinish()

        and:
        gradle.standardOutput.contains("Build operation '${workAction.packageName}.${workAction.name}' started")