builder.parentChildMapping(parent.getNodeId(), child.getNodeId(), artifactsId);
    }

    @Override
    public void addNodeArtifacts(DependencyGraphNode node, int artifactsId) {
        builder.nodeArtifacts(node.getNodeId(), artifactsId);
    }

    @Override
    public void newResolvedDependency(DependencyGraphNode node) {

        def v1State = Mock(VariantGraphResolveState) {
            getInstanceId() >> 1
            getVariantResult(null) >> v1Result
        }
        def v1 = Mock(ResolvedGraphVariant) {
            getNodeId() >> 1
            getOwner() >> componentIdentifier
            getResolveState() >> v1State
            getExternalVariant() >> null
        }
        def v3Result = Mock(ResolvedVariantResult)

    boolean isConstraint();

    /**
     * Returns the simple id of the source variant, as per {@link ResolvedGraphVariant#getNodeId()}.
     */
    Long getFromVariant();

    /**
     * Returns the simple id of the selected variant, as per {@link ResolvedGraphVariant#getNodeId()}.
     */
    @Nullable
    Long getSelectedVariant();

public interface ResolvedGraphVariant {
    /**
     * Returns a simple id for this node, unique across all nodes in the same graph.
     * This id cannot be used across graphs.
     */
    Long getNodeId();

    VariantGraphResolveState getResolveState();

    @Nullable
    ResolvedGraphVariant getExternalVariant();

        for (ResolvedGraphVariant variant : component.getSelectedVariants()) {
            resolutionResultBuilder.visitSelectedVariant(variant.getNodeId(), variant.getResolveState().getVariantResult(null));
        }

        if (includeAllSelectableVariantResults) {

    @Nullable
    @Override
    public Long getSelectedVariant() {
        NodeState node = getSelectedNode();
        if (node == null) {
            return null;
        } else {
            return node.getNodeId();
        }
    }

    @Nullable
    public NodeState getSelectedNode() {
        if (resolvedVariant != null) {
            return resolvedVariant;
        }

    }

    @Override
    public void writeVariantResult(ResolvedGraphVariant variant, Encoder encoder) throws Exception {
        encoder.writeSmallLong(variant.getNodeId());
        VariantGraphResolveState state = variant.getResolveState();
        if (state.isAdHoc()) {
            writeVariantData(encoder, state);
        } else {

        }

        return artifactsByNodeId.computeIfAbsent(toNode.getNodeId(), (LongFunction<ArtifactsForNode>) value -> {
            int id = nextId++;

	if err != nil {
		return "", 0, nil, err
	}

	topology := res.GetAccessibleTopology()
	if topology != nil {
		accessibleTopology = topology.Segments
	}
	return res.GetNodeId(), res.GetMaxVolumesPerNode(), accessibleTopology, nil
}

func (c *csiDriverClient) NodePublishVolume(
	ctx context.Context,
	volID string,
	readOnly bool,
	stagingTargetPath string,
	targetPath string,

	err error) {
	resp, err := c.nodeClient.NodeGetInfo(ctx, &csipbv1.NodeGetInfoRequest{})
	topology := resp.GetAccessibleTopology()
	if topology != nil {
		accessibleTopology = topology.Segments
	}
	return resp.GetNodeId(), resp.GetMaxVolumesPerNode(), accessibleTopology, err
}

func (c *fakeCsiDriverClient) NodeGetVolumeStats(ctx context.Context, volID string, targetPath string) (
	usageCountMap *volume.Metrics, err error) {