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

    /**

                    .redirectErrorStream()
                    .workingDir(new File(".").absoluteFile) //does not matter
                    .build()
            e.start()
            def result = e.waitForFinish()
            CAN_KILL = result.exitValue == 0
        } else {
            CAN_KILL = false
        }
    }

        }
        return bash("ps -o pid,ppid,args -p ${pids.join(' -p ')}").split("\\n")
    }

    /**
     * Blocks until the process represented by {@link #pid} has exited.
     */
    void waitForFinish() {
        if (pid == null) {
            throw new RuntimeException("Unable to wait for process to finish because provided pid is null!")
        }
        if (OperatingSystem.current().unix) {

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

     */
    void abort();

    /**
     * Waits for the process to finish. Returns immediately if the process has already completed.
     *
     * @return result
     */
    ExecResult waitForFinish();

    /**
     * Returns the result of the process execution, if it has finished.  If the process has not finished, returns null.
     */
    @Nullable
    ExecResult getExecResult();

            assert handle.standardOutput.contains('Listening for transport dt_socket at address')
        }

        then:
        debugClient.connect().dispose()

        then:
        handle.waitForFinish()

        where:
        taskName << ['runJavaExec', 'runExecOperationsJavaExec', 'test']
    }

    @Issue("https://github.com/gradle/gradle/issues/20644")

        def handle1 = executer.withTasks('tasks').start()
        def handle2 = executer.withTasks('tasks').start()

        and: "they both complete"
        def result1 = handle1.waitForFinish()
        def result2 = handle2.waitForFinish()

        then: "both builds ran, with the settings script editing the archive atomically"
        result1.assertTasksExecuted(':tasks')
        result2.assertTasksExecuted(':tasks')