*/
    ExecutionResult assertTasksExecutedInOrder(Object... taskPaths);

    /**
     * Asserts that exactly the given set of tasks have been executed in any order.
     */
    ExecutionResult assertTasksExecuted(Object... taskPaths);

    /**
     * Asserts that the given task has been executed.
     */
    ExecutionResult assertTaskExecuted(String taskPath);

    /**

public class ErrorsOnStdoutScrapingExecutionResult implements ExecutionResult {
    private final ExecutionResult delegate;

    public ErrorsOnStdoutScrapingExecutionResult(ExecutionResult delegate) {
        this.delegate = delegate;
    }

    @Override
    public ExecutionResult getIgnoreBuildSrc() {
        return new ErrorsOnStdoutScrapingExecutionResult(delegate.getIgnoreBuildSrc());

    }

    private <T> T runBuild(Supplier<ExecutionResult<? extends T>> action) {
        return state.transition(State.NotStarted, State.Complete, () -> {
            ExecutionResult<? extends T> result;
            try {
                result = action.get();
            } catch (Throwable t) {
                result = ExecutionResult.failed(t);
            }

    }

    def verifyTestResultWith(TestExecutionResult executionResult, TestResultOutputAssociation outputAssociation) {
        executionResult.assertTestClassesExecuted("org.FailingTest", "org.PassingTest", "org.MixedMethodsTest", "org.NoOutputsTest", "org.EncodingTest", "org.ParameterizedTest", "org.OutputLifecycleTest")

        def mixedMethods = executionResult.testClass("org.MixedMethodsTest")
                .assertTestCount(4, 2, 0)

    override fun scheduleAndRunRequestedTasks(taskSelector: EntryTaskSelector?): ExecutionResult<Void> {
        val scheduleTaskSelectorPostProcessing: BuildTreeWorkGraphBuilder? = taskSelector?.let { selector ->
            { rootBuildState ->
                addFinalization(rootBuildState, selector::postProcessExecutionPlan)
            }
        }
        val executionResult = workGraph.withNewWorkGraph { graph ->

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

        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
    }

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)

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