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

        for (DependencyGraphVisitor visitor : visitors) {
            visitor.start(root);
        }
    }

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

    @Override
    public void visitSelector(DependencyGraphSelector selector) {

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

    /**
     * Visits a node of the graph. Includes the root. This method is called for all nodes before {@link #visitEdges(DependencyGraphNode)} is called.
     */
    default void visitNode(DependencyGraphNode node) {}

    /**
     * Visits a selector. This method is called for all selectors before {@link #visitEdges(DependencyGraphNode)} is called.
     */

        List<String> flatten() {
            final List<String> prefixes = new ArrayList<String>();
            rootNode.visitHierarchy(0, new NodeVisitor() {
                @Override
                public void visitNode(int depth, Node node) {
                    if (depth == 0) {
                        prefixes.add(node.prefix);
                    } else {

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

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

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

            }
        }

        fun visitNode(node: DeclarativeDocument.DocumentNode) {
            when (node) {
                is ElementNode -> {
                    elementResolution[node] = elementResolution(document.languageTreeMappingContainer.data(node) as FunctionCall)
                    node.elementValues.forEach(::visitValue)
                    node.content.forEach(::visitNode)
                }

    public ResolvedConfigurationDependencyGraphVisitor(ResolvedConfigurationBuilder builder) {
        this.builder = builder;
    }

    @Override
    public void visitNode(DependencyGraphNode node) {
        builder.newResolvedDependency(node);
        for (DependencyGraphEdge dependency : node.getIncomingEdges()) {
            if (dependency.getFrom().isRoot()) {

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