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

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

        result = gradleHandle.waitForFinish()
        result.output.count(prompt) == 1
    }

    void runWithInterruptedInput(String task) {
        interactiveExecution()
        def gradleHandle = executer.withTasks(task).start()
        writeToStdInAndClose(gradleHandle, EOF)
        result = gradleHandle.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:

        def runReleaseHandle = executer.withTasks("build2").usingInitScript(initScriptFile).start()

        and:
        def releaseResult = runReleaseHandle.waitForFinish()
        def blockingResult = runBlockingHandle.waitForFinish()

        then:
        blockingResult.ignoreBuildSrc.assertTasksExecuted(":build1")
        releaseResult.ignoreBuildSrc.assertTasksExecuted(":build2")

        cleanup:

        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:

    }

    @Override
    public ExecutionResult waitForFinish() {
        return waitForStop(false);
    }

    @Override
    public ExecutionFailure waitForFailure() {
        return (ExecutionFailure) waitForStop(true);
    }

    @Override
    public void waitForExit() {
        getExecHandle().waitForFinish().rethrowFailure();
    }

     */
    GradleHandle cancelWithEOT();

    /**
     * Blocks until the build is complete and assert that the build completed successfully.
     */
    ExecutionResult waitForFinish();

    /**
     * Blocks until the build is complete and assert that the build completed with a failure.
     */
    ExecutionFailure waitForFailure();

    /**