given:
        startWithState([])

        DependencyGraphNode node = Mock()
        DependencyGraphComponent component = Mock()

        when:
        visitor.visitNode(node)

        then:
        2 * node.owner >> component
        1 * component.componentId >> newId(mid, '1.0')
    }

    def 'ignores node having a ModuleComponentIdentifier but an empty version'() {

        this.graphVariantSelector = graphVariantSelector;
        this.consumerSchema = consumerSchema;
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        artifactResults.visitNode(node);
    }

    @Override
    public void visitEdges(DependencyGraphNode node) {
        boolean hasTransitiveIncomingEdge = false;

    public InMemoryResolutionResultBuilder(boolean includeAllSelectableVariantResults) {
        this.includeAllSelectableVariantResults = includeAllSelectableVariantResults;
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        DependencyGraphComponent component = node.getOwner();
        resolutionResultBuilder.startVisitComponent(component.getResultId(), component.getSelectionReason(), component.getRepositoryName());

 * the resolution.
 */
public class FailOnVersionConflictGraphVisitor implements DependencyGraphVisitor {

    private final Set<Conflict> allConflicts = new LinkedHashSet<>();

    @Override
    public void visitNode(DependencyGraphNode node) {
        DependencyGraphComponent owner = node.getOwner();
        ComponentSelectionReason selectionReason = owner.getSelectionReason();
        if (selectionReason.isConflictResolution()) {

    }

    @Override
    public void start(RootGraphNode root) {
        this.rootId = root.getOwner().getComponentId();
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        ComponentIdentifier componentId = node.getOwner().getComponentId();
        if (!rootId.equals(componentId) && componentId instanceof ProjectComponentIdentifierInternal) {

        } else {
            modulesToBeLocked = Collections.emptyMap();
            allResolvedModules = new HashSet<>();
        }
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        boolean changing = false;
        ComponentIdentifier identifier = node.getOwner().getComponentId();
        ComponentGraphResolveMetadata metadata = node.getOwner().getMetadataOrNull();

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

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

        private static class CalculateTaskGraphResult implements Result, CustomOperationTraceSerialization {