started.release("item2")

        then:
        finished.waitForAllPendingCalls()

        then:
        finished.releaseAll()
        started.release("item3")

        then:
        gradle.waitForFinish()

        and:
        assertWorkItemsExecuted("item1", "item2", "item3")

        where:
        isolationMode << ISOLATION_MODES
    }

    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
    }

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

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

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

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

            try {
                execHandle.start();
                ExecResult result = execHandle.waitForFinish();
                // Exit code 0 = success
                // Exit code 1 = failed test(s)
                // anything else is considered an execution failure

        (1..projectCount).each { count ->
            handles << executer.inDirectory(file(createProjectName(count))).withTasks(taskNames).start()
        }
        handles.each { handle ->
            handle.waitForFinish()
        }
    }

    private void parallelBuildSucceeds(String... taskNames) {
        executer.withBuildJvmOpts('-Xmx1024m')
        args('--parallel')
        succeeds taskNames
    }

        builder.setIgnoreExitValue(true);
        return builder.build();
    }

    private void executeCompiler(ExecHandle handle) {
        handle.start();
        ExecResult result = handle.waitForFinish();
        if (result.getExitValue() != 0) {
            throw new CompilationFailedException(result.getExitValue());
        }
    }

        then:
        sftpServer.clearSessions()
        sftpServer.expectLstat("/")
        sleep(1000)

        when:
        sync.releaseAll()

        then:
        gradle.waitForFinish()
    }

    String getSftpTask() {
        return """
            import org.gradle.internal.resource.transport.sftp.SftpClientFactory
            import org.gradle.api.artifacts.repositories.PasswordCredentials

        out =~ /\n\s*\d+\s+BUSY\s+([\w\.\+\-]+)/
        out =~ /\n\s*12346\s+STOPPED\s+\(GRACEFUL_EXPIRE_REASON\)/

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

    def "reports stopped status of recently stopped daemons"() {
        given: