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

            containsTestExecutionWorkInProgressLine(gradleHandle, ':test', testClass2.renderedClassName)
        }

        testExecution.release(2)
        gradleHandle.waitForFinish()

        where:
        testClass1                    | testClass2                    | description
        JavaTestClass.PRESERVED_TEST1 | JavaTestClass.PRESERVED_TEST2 | 'preserved'

        kill(pid1)

        when:
        handler.releaseAll()
        result = gradle.waitForFinish()

        then:
        outputContainsKilledWorkerWarning()
    }

    static void kill(long pid1) {
        def proc = new ProcessFixture(pid1)
        proc.kill(false)
        proc.waitForFinish()
    }

    void outputContainsKilledWorkerWarning() {

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

    /**

        handle.waitForAllPendingCalls()
        assertOutputContains(gradle, "Before")
        handle.releaseAll()
        result = gradle.waitForFinish()

        then:
        result.groupedOutput.task(':log').output == 'Before\nAfter'

        cleanup:
        gradle?.waitForFinish()
    }

    String callFromBuild(String name) {
        return "new URL('${server.uri}/${name}').text"
    }

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

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