/** Returns the children of the specified node. Must not contain null. */
  public abstract Iterable<T> children(T root);

  /**
   * Returns an unmodifiable iterable over the nodes in a tree structure, using pre-order traversal.
   * That is, each node's subtrees are traversed after the node itself is returned.
   *
   * <p>No guarantees are made about the behavior of the traversal when nodes change while iteration

     *
     * @param tree "dirty" tree root
     * @param versionedVertices true if graph nodes should be versioned (different versions -> different nodes)
     * @param scopedVertices true if graph nodes should be versioned and scoped
     * (different versions and/or scopes -> different nodes)
     *
     */
    public MetadataGraph(MetadataTreeNode tree, boolean versionedVertices, boolean scopedVertices)

import java.util.List;

/**
 * MetadataGraph node - as it's a directed graph - holds adjacency lists for incident and exident nodes
 *
 *
 */
@Deprecated
public class MetadataGraphNode {
    /** node payload */
    MavenArtifactMetadata metadata;

    /** nodes, incident to this (depend on me) */
    List<MetadataGraphNode> inNodes;

    /** nodes, exident to this (I depend on) */

        nodes.add(node);
    }

    /**
     * find a node by the GAV (metadata)
     *
     * @param md
     */
    public MetadataGraphNode findNode(MavenArtifactMetadata md) {
        for (MetadataGraphNode mgn : nodes) {
            if (mgn.metadata.equals(md)) {
                return mgn;
            }
        }

        MetadataGraphNode node = new MetadataGraphNode(md);
        addNode(node);

        CollectResult collectResult = system.collectDependencies(session, collectRequest);

        List<DependencyNode> nodes = collectResult.getRoot().getChildren();
        assertEquals(2, nodes.size());
        checkUtSimpleArtifactDependencies(
                nodes.get(0).getDependency(), nodes.get(1).getDependency());
    }

    @Test
    void testResolveArtifact() throws Exception {

@Deprecated
public interface GraphConflictResolver {
    String ROLE = GraphConflictResolver.class.getName();

    /**
     * Cleanses the supplied graph by leaving only one directed versioned edge\
     * between any two nodes, if multiple exists. Uses scope relationships, defined
     * in <code>ArtifactScopeEnum</code>
     *
     * @param graph the "dirty" graph to be simplified via conflict resolution

        // create runner instance
        runner = new OpenSearchRunner();
        // create ES nodes
        final String clusterName = UUID.randomUUID().toString();
        runner.onBuild((number, settingsBuilder) -> {
            settingsBuilder.put("http.cors.enabled", true);
            settingsBuilder.put("discovery.type", "single-node");
        }).build(newConfigs().clusterName(clusterName).numOfNode(1));

        runner = new OpenSearchRunner();
        // create ES nodes
        final String clusterName = UUID.randomUUID().toString();
        runner.onBuild((number, settingsBuilder) -> {
            settingsBuilder.put("http.cors.enabled", true);
            settingsBuilder.put("http.cors.allow-origin", "*");
            settingsBuilder.put("discovery.type", "single-node");
        }).build(newConfigs().clusterName(clusterName).numOfNode(1));

            Collection<org.apache.maven.artifact.Artifact> artifacts,
            Collection<? extends DependencyNode> nodes,
            List<String> trail,
            DependencyFilter filter) {
        for (DependencyNode node : nodes) {
            org.apache.maven.artifact.Artifact artifact = toArtifact(node.getDependency());

            List<String> nodeTrail = new ArrayList<>(trail.size() + 1);

        Set<ResolutionNode> set = new LinkedHashSet<>();

        for (List<ResolutionNode> nodes : resolvedArtifacts.values()) {
            for (ResolutionNode node : nodes) {
                if (!node.equals(root) && node.isActive()) {
                    Artifact artifact = node.getArtifact();

                    try {
                        if (node.filterTrail(filter)) {