forkingGradleHandle.execHandleRef.set(execHandle)
    }

    def "wait for finish for successful execution"() {
        when:
        def executionResult = forkingGradleHandle.waitForFinish()

        then:
        1 * execHandle.waitForFinish() >> execResult
        0 * execHandle._
        1 * execResult.rethrowFailure()
        1 * execResult.getExitValue() >> SUCCESS_EXIT_VALUE
        1 * resultAssertion.execute(_)

        executer.withTasks('resolve')
        def build1 = executer.start()

        executer.withTasks('resolve')
        def build2 = executer.start()

        build1.waitForFinish()
        build2.waitForFinish()

        // Wait for each build to list versions
        httpServer.expectConcurrent(repo.listVersions(), repo.listVersions())

        executer.withTasks('resolve')

        this.execution = execution;
        forwarder.start();
    }

    @Override
    public void dispatch(Object event) {
        queue.offer(event);
    }

    public void waitForFinish() {
        forwarder.waitForFinish();
    }

    private class ForwardEvents extends Thread {
        private volatile boolean stopped;
        private boolean ableToSend = true;

        public ForwardEvents() {

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

        block2.waitForAllPendingCalls()

        // Finish up first build while second build is still running
        block1.releaseAll()
        def result1 = build1.waitForFinish()

        block2.releaseAll()
        def result2 = build2.waitForFinish()

        then:
        result1.output.count("Transforming") == 1
        result1.output.count("Transforming thing.jar to Red") == 1

        rootBuildScript.releaseAll()

        and:
        bBuildScript.waitForAllPendingCalls()
        assertHasWorkInProgress(":b")
        bBuildScript.releaseAll()

        and:
        gradle.waitForFinish()
    }

    def "shows work in progress with included build"() {
        createDirs("child")
        settingsFile << """
            includeBuild "child"
        """
        buildFile << """

        handle.releaseAll()
        result = gradle.waitForFinish()

        then:
        result.groupedOutput.task(':a:longRunning').outputs.size() == 1
        result.groupedOutput.task(':a:longRunning').output == "longRunning has started...\nlongRunning has finished..."

        cleanup:
        gradle?.waitForFinish()
    }

        and:
        def handle2 = executer.withArguments('b:build', '-is').start()
        handle2.waitForFinish()
        handle1.waitForFinish()

        and:
        file("a/build/libs/a.jar").assertExists()
        file("b/build/libs/b.jar").assertExists()
    }

        block2.waitForAllPendingCalls()

        // Finish up build 1 and 2
        block1.releaseAll() // finish build 1 while build 2 is still running
        build1.waitForFinish()
        block2.releaseAll()
        build2.waitForFinish()
    }

            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: