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

        when:
        handle.waitForFinish()
        handle.waitForFinish()

        then:
        execHandle.state == ExecHandleState.SUCCEEDED
    }

    void "understands when application exits with non-zero"() {
        given:
        def execHandle = handle().args(args(BrokenApp.class)).build()

        when:
        def result = execHandle.start().waitForFinish()

        then:

        def gradle2 = executer.withTasks("block").withArguments("--debug", "-PbuildNum=2").start()

        then:
        gradle1.waitForFinish()
        gradle2.waitForFinish()

        and:
        daemons.daemons.size() == 2
    }

    String getUrl(String event) {
        return "http://localhost:${server.port}/${event}"
    }

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

            assertReleaseSignalTriggered(build2)
            assertReleaseSignalTriggered(build3)
        }

        then:
        receivingLock.close()
        build1.waitForFinish()
        build2.waitForFinish()
        build3.waitForFinish()
    }

    // This test simulates a long running Zinc compiler setup by running code similar to ZincScalaCompilerFactory through the worker API.

            assert gradle.standardOutput =~ regexFor(message)
        }
    }

    String regexFor(String message) {
        /<.*> $message \[[\dms ]+]/
    }

    void waitForFinish() {
        result = gradle.waitForFinish()
        outputDoesNotContain("More progress was logged than there should be")
    }

    String buildFinishedCall(String name) {
        """

        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

        block1.releaseAll()
        def result1 = build1.waitForFinish()

        // Run build 3 before build 2 has completed. This happens after build 2 has run 'a'. Should see 'a' is up-to-date
        def result3 = executer.withTasks("a").run()

        // Finish up build 2
        block2.releaseAll()
        def result2 = build2.waitForFinish()

        then:
        result1.assertTaskSkipped(':a')