class TaskOrderSpecsTest extends Specification {
    def "can match order exactly (#executedTasks)"() {
        def spec = exact(':a', ':b', ':c')

        when:
        spec.assertMatches(-1, executedTasks)

        then:
        noExceptionThrown()

        where:
        executedTasks << [
            [':a', ':b', ':c'],
            [':a', ':b', ':c', ':d'],
            [':z', ':a', ':b', ':c'],

        then:
        executedTasks == [a, b, c, d]
        failures.empty
    }

    def "executes dependencies in name order"() {
        Task a = task("a")
        Task b = task("b")
        Task c = task("c")
        Task d = task("d", b, a, c)

        when:
        populateAndExecute([d])

        then:
        executedTasks == [a, b, c, d]
        failures.empty
    }

        protected final List<String> executedTasks;
        protected final Set<String> skippedTasks;
        private final ExecutionResult outputResult;

        InProcessExecutionResult(List<String> executedTasks, Set<String> skippedTasks, ExecutionResult outputResult) {
            this.executedTasks = executedTasks;
            this.skippedTasks = skippedTasks;

        addToGraphAndPopulate([b])
        assert executedTasks == [a]

        when:
        executionPlan = newExecutionPlan()
        addToGraphAndPopulate([d])
        executionPlan.setContinueOnFailure(true)

        then:
        executionPlan.tasks as List == [b, c, d]
        executedTasks == [c]

        when:
        finalizedPlan.collectFailures(failures)

        and:
        result.assertTaskExecuted(':a')
        result.assertTaskExecuted(':b')
        result.assertTaskNotExecuted(':c')

        and:
        result.executedTasks == [":a", ":b"]
        result.skippedTasks == [":b"] as Set

        and:
        result.assertTasksNotSkipped(":a")
        result.assertTasksNotSkipped(":a", ":a", [":a"])

        and:

        file("child/build.gradle") << """
            task executedTask {
                doLast {
                    // Do something
                }
            }
        """
        buildFile << """
            executedTask.dependsOn(gradle.includedBuild("child").task(":executedTask"))
        """

        when:
        run("executedTask")

        then:

        return buildOperationRunner.call(new ExecuteTasks(gradle, plan));
    }

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

        public ExecuteTasks(GradleInternal gradle, FinalizedExecutionPlan plan) {
            this.gradle = gradle;

Laura Kassovic <******@****.***> 1701107622 -0800

        def executionResult = controller.executeTasks(plan1)
        executionResult.failures.empty

        controller.prepareToScheduleTasks()
        def plan2 = controller.newWorkGraph()
        controller.populateWorkGraph(plan2) {}
        controller.finalizeWorkGraph(plan2)
        def executionResult2 = controller.executeTasks(plan2)
        executionResult2.failures.empty

Laura Kassovic <******@****.***> 1701107622 -0800