.setStandardOutput(output)
                .workingDir(new File(".").absoluteFile) //does not matter
                .build()
        e.start()
        def result = e.waitForFinish()
        result.rethrowFailure()

        return output.toString()
    }

    private static Object[] killArgs(Long pid, boolean killTree) {
        if (OperatingSystem.current().unix) {
            // start shell, read script from stdin

        project.gradle.services.get(BuildOutputCleanupRegistry).resolveOutputs()
        executionServices.get(TaskExecuter).execute((TaskInternal) task, (TaskStateInternal) task.state, taskExecutionContext)
        task.state.rethrowFailure()
    }

    protected static boolean assertHasMatchingCause(Throwable t, Predicate<String> predicate) {
        if (t == null) {
            return false
        }

        def cause = t

        Stub(TaskRequiredServices)
    }

    void failure(TaskInternal task, final RuntimeException failure) {
        task.state.getFailure() >> failure
        task.state.rethrowFailure() >> { throw failure }
    }

    private static class MockLock implements ResourceLock {
        final Thread owner = Thread.currentThread()
        final ProjectInternal project
        boolean locked

        def results = dependencyResolver.resolveGraph(resolveContext)

        then:
        def resolvedConfig = results.legacyResults.resolvedConfiguration
        !resolvedConfig.hasError()
        resolvedConfig.rethrowFailure()

        resolvedConfig.getFiles(Specs.<Dependency> satisfyAll()).isEmpty()
        resolvedConfig.getFirstLevelModuleDependencies().isEmpty()
        resolvedConfig.getResolvedArtifacts().isEmpty()

            stoppable.requestStop();
        }
    }

    private void onProcessStop(ExecResult execResult) {
        lock.lock();
        try {
            try {
                execResult.rethrowFailure().assertNormalExitValue();
            } catch (Throwable e) {
                processFailure = e;
            }
            running = false;
            condition.signalAll();
        } finally {

                // Exit code 1 = failed test(s)
                // anything else is considered an execution failure
                if (result.getExitValue() != 0 && result.getExitValue() != 1) {
                    result.rethrowFailure().assertNormalExitValue();
                }
            } catch (ExecException e) {
                stdOut.endOfStream(e);
                stdErr.endOfStream(null);
            } finally {

                        }
                    }

                    if (state.hasFailure()) {
                        state.rethrowFailure();
                    } else {
                        context.setResult(ConfigureProjectBuildOperationType.RESULT);
                    }
                } finally {
                    state.configured();

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

        then:
        result.rethrowFailure()
        1 * streamsHandler.connectStreams(_ as Process, "foo proc", _ as Executor)
        1 * streamsHandler.start()
        1 * streamsHandler.stop()
        0 * streamsHandler._
    }

    @Timeout(2)

        _ * mock.identityPath >> project.identityPath.child(name)
        _ * mock.project >> project
        _ * mock.state >> Stub(TaskStateInternal) {
            getFailure() >> failure
            rethrowFailure() >> { throw failure }
        }
        _ * mock.taskDependencies >> Stub(TaskDependencyInternal)
        _ * mock.lifecycleDependencies >> Stub(TaskDependencyInternal)