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:

        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

                }
                currentlyRunning = this;
            }
            try {
                if (plan != null) {
                    return controller.executeTasks(plan);
                } else {
                    return ExecutionResult.succeeded();
                }
            } finally {
                synchronized (lock) {
                    currentlyRunning = null;

        private BuildStateRegistry getBuildStateRegistry() {
            return gradle.getServices().get(BuildStateRegistry.class);
        }
    }

    @Override
    public ExecutionResult<Void> executeTasks(BuildWorkPlan plan) {
        // Execute tasks and transition back to "configure", as this build may run more tasks;
        DefaultBuildWorkPlan workPlan = unpack(plan);
        if (workPlan.empty) {

        void finalizeWorkGraph(BuildWorkPlan workPlan) {
            plan.determineExecutionPlan()
            finalizedPlan = plan.finalizePlan()
        }

        @Override
        ExecutionResult<Void> executeTasks(BuildWorkPlan buildPlan) {
            return services.planExecutor.process(finalizedPlan.asWorkSource()) { node ->
                if (node instanceof SelfExecutingNode) {
                    node.execute(null)