fun stopDaemons() {
        build("--stop")
    }

    protected
    fun buildForCacheInspection(vararg arguments: String): ExecutionResult =
        executerForCacheInspection(*arguments).run()

    protected
    fun buildWithDaemonHeapSize(heapMb: Int, vararg arguments: String): ExecutionResult =
        executerForCacheInspection(*arguments)
            .withBuildJvmOpts("-Xms${heapMb}m", "-Xmx${heapMb}m")
            .run()

import org.gradle.internal.DefaultTaskExecutionRequest
import org.gradle.internal.RunDefaultTasksExecutionRequest
import org.gradle.internal.build.BuildLifecycleController
import org.gradle.internal.build.ExecutionResult
import org.gradle.util.TestUtil
import spock.lang.Specification

import java.util.function.Consumer

class DefaultBuildTreeLifecycleControllerTest extends Specification {
    def gradle = Mock(GradleInternal)

        when:
        def executionResult = forkingGradleHandle.waitForFinish()

        then:
        1 * execHandle.waitForFinish() >> execResult
        0 * execHandle._
        1 * execResult.rethrowFailure()
        1 * execResult.getExitValue() >> SUCCESS_EXIT_VALUE
        1 * resultAssertion.execute(_)
        executionResult instanceof OutputScrapingExecutionResult
    }

        super(distribution, provider)
        this.container = container
    }

    @Override
    protected ExecutionResult doRun() {
        ExecutionResult result = executeInContainer()
        if (result instanceof ExecutionFailure) {
            throw new AssertionError("Expected the build to pass but it failed")
        }
        result
    }

            }
        }
        return outputFiles;
    }

    public List<ExecutionResult> succeeds() {
        return succeeds(MSBuildAction.BUILD);
    }

    public List<ExecutionResult> succeeds(MSBuildAction action) {
        cleanupOutputDir();
        List<ExecutionResult> results = new ArrayList<>();

        withArgument(toTargetArgument(action));

                .run()
        }
        return OutputScrapingExecutionResult.from(output.toString(), error.toString())
    }

    ExecutionResult runBuildWithToolingConnection(Function<ProjectConnection, ExecutionResult> action) {
        return run {
            def result = null
            usingToolingConnection(workingDir) {
                result = action(it)
            }
            result

        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public ExecutionResult<Void> execute(GradleInternal gradle, FinalizedExecutionPlan plan) {
        return buildOperationRunner.call(new ExecuteTasks(gradle, plan));
    }

    private class ExecuteTasks implements CallableBuildOperation<ExecutionResult<Void>> {
        private final GradleInternal gradle;
        private final FinalizedExecutionPlan plan;

        return this;
    }

    @Override
    public ExecutionResult assertHasPostBuildOutput(String expectedOutput) {
        return assertContentContains(postBuild.withNormalizedEol(), expectedOutput, "Post-build output");
    }

    @Override
    public ExecutionResult assertNotPostBuildOutput(String expectedOutput) {

        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public ExecutionResult<Void> execute(BuildTreeWorkGraph.FinalizedGraph graph) {
        return buildOperationRunner.call(new CallableBuildOperation<ExecutionResult<Void>>() {
            @Override
            public ExecutionResult<Void> call(BuildOperationContext context) {
                return delegate.execute(graph);
            }

        super(stdinPipe, isDaemon, resultAssertion, outputEncoding, execHandleFactory, durationMeasurement);
    }

    @Override
    protected ExecutionResult toExecutionResult(String output, String error) {