then:
        ConcurrentTestUtil.poll() {
            // Connect, resume threads, and disconnect from VM
            jdwpClient.connect().dispose()
        }
        gradle.waitForFinish()
    }

    @Issue('https://github.com/gradle/gradle/issues/18084')
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor)
    @Flaky(because = "https://github.com/gradle/gradle-private/issues/3636")

            connection.notifyDaemonsAboutChangedPaths(toPaths(changedPaths))
        }

        then:
        block.releaseAll()
        build.waitForFinish()
        pathsInvalidated()

        cleanup:
        block?.releaseAll()
        build?.waitForFinish()
    }

    @TargetGradleVersion(">=3.0 <6.1")
    def "invalidating paths has no effect on older daemons"() {
        when:

        cancelBuild()

        then:
        daemons.daemon.becomesIdle()

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

        when:
        handler = blockingHttpServer.expectAndBlock("/block")
        startBuild("compileJava")

        then:
        handler.waitForAllPendingCalls()

        then:

    def "concurrent downloads do not stomp over each other"() {
        given:
        prepareWrapper(server.uri("gradle-bin.zip"))

        when:
        def results = [1..4].collect { wrapperExecuter.start() }*.waitForFinish()

        then:
        results.findAll { it.output.contains("Downloading") }.size() == 1
    }

        // // https://github.com/gradle/dotcom/issues/6071
        builder.environment("JAVA_OPTS", "")
        return builder.build()
    }

    ExecResult run() {
        return build().start().waitForFinish()
    }

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

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

            assert handle.standardOutput.contains("there? [yes, no]")
        }
        handle.stdinPipe.write((answer + TextUtil.platformLineSeparator).bytes)
        handle.stdinPipe.close()
        result = handle.waitForFinish()
    }

    def "exposes correct start parameter"() {
        given:
        buildFile << """
            def serviceRef = gradle.serviceRef
            t.doLast {