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 {

        store.write(encoder -> {
            encoder.writeByte(ROOT);
            encoder.writeSmallLong(root.getOwner().getResultId());
        });
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        final DependencyGraphComponent component = node.getOwner();
        if (visitedComponents.add(component.getResultId())) {
            store.write(encoder -> {

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

String[], ResolveData, java.util.List); private void fetchDependencies(VisitNode, String, boolean); private void doFetchDependencies(VisitNode, String); private static String getDependenciesFetch(IvyNode, String); private void resolveConflict(VisitNode, String); private boolean resolveConflict(VisitNode, VisitNode, String, java.util.Collection); private static java.util.Collection computeConflicts$baa5bc6(VisitNode, VisitNode, java.util.Collection, java.util.Collection); public final org.apache....

        }

        // Visit the nodes prior to visiting the edges
        for (NodeState nodeState : resolveState.getNodes()) {
            if (nodeState.shouldIncludedInGraphResult()) {
                visitor.visitNode(nodeState);
            }
        }

        // Collect the components to sort in consumer-first order
        LinkedList<ComponentState> queue = new LinkedList<>();

            return failures.keySet()
        }

        @Override
        void start(RootGraphNode root) {
            this.root = root
        }

        @Override
        void visitNode(DependencyGraphNode node) {
            components.add(node.owner.moduleVersion)
        }

        @Override
        void visitEdges(DependencyGraphNode node) {
            node.outgoingEdges.each {

            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