return taskGraph.execute(plan);
    }

    private void bindAllReferencesOfProject(FinalizedExecutionPlan plan) {
        Set<Project> seen = new HashSet<>();
        plan.getContents().getScheduledNodes().visitNodes((nodes, entryNodes) -> {
            for (Node node : nodes) {
                if (node instanceof LocalTaskNode) {
                    ProjectInternal taskProject = node.getOwningProject();

         *
         * @param visitor the consumer of nodes and entry nodes
         */
        void visitNodes(BiConsumer<List<Node>, Set<Node>> visitor);
    }

        this.scheduledNodes = ImmutableList.copyOf(scheduledNodes);
        this.entryNodes = ImmutableSet.copyOf(entryNodes);
    }

    @Override
    public void visitNodes(BiConsumer<List<Node>, Set<Node>> visitor) {
        visitor.accept(scheduledNodes, entryNodes);
    }

    /**
     * Returns the list of the scheduled nodes in the scheduling order.
     *

                getTaskIdentity() >> ti1
            }
        }
        List<Node> nodes = [t]

        def scheduledNodesStub = Stub(QueryableExecutionPlan.ScheduledNodes) {
            visitNodes(_) >> { BiConsumer<List<Node>, Set<Node>> consumer ->
                consumer.accept(nodes, new HashSet<Node>(nodes))
            }
        }

        def executionPlan = Stub(ExecutionPlan) {

            Set<NodeBuilder> result = new LinkedHashSet<>()
            visitNodes(this.root, result)
            return result.collect { it.artifacts }.flatten()
        }

        Set<String> getFiles() {
            Set<NodeBuilder> result = new LinkedHashSet()
            result.add(this.root)
            visitNodes(this.root, result)
            return result.collect { node -> node.files }.flatten()
        }

            PlannedNodeGraph.Collector collector = new PlannedNodeGraph.Collector(converterRegistry);
            scheduledWork.visitNodes((nodes, entryNodes) -> collector.collectNodes(nodes));
            return collector.getGraph();
        }

        private static class CalculateTaskGraphResult implements Result, CustomOperationTraceSerialization {

        return allTasks;
    }

    @Override
    public void visitScheduledNodes(BiConsumer<List<Node>, Set<Node>> visitor) {
        executionPlan.getContents().getScheduledNodes().visitNodes(visitor);
    }

    @Override
    public Set<Task> getDependencies(Task task) {
        Node node = executionPlan.getContents().getNode(task);
        ImmutableSet.Builder<Task> builder = ImmutableSet.builder();

            assert finalizedPlan.executionState() == WorkSource.State.MaybeWorkReadyToStart
        }
    }

    List<Node> getScheduledNodes() {
        def result = []
        executionPlan.scheduledNodes.visitNodes { nodes, entryNodes -> result.addAll(nodes) }
        return result
    }

    private static class TestNode extends CreationOrderedNode implements SelfExecutingNode {
        final Throwable failure

        conf2.outgoingEdges >> [dep(selector3, 2, 4)]

        builder.start(root)

        builder.visitNode(root)
        builder.visitNode(conf1)
        builder.visitNode(conf2)
        builder.visitNode(node(3, "org", "dep2", "1.0"))
        builder.visitNode(node(4, "org", "dep3", "1.0"))

        builder.visitSelector(selector1)
        builder.visitSelector(selector2)

        this.visitors = visitors;
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        for (DependencyArtifactsVisitor visitor : visitors) {
            visitor.visitNode(node);
        }
    }

    @Override