tree.put("tree", 3);
    assertThat(tree.keySet()).containsExactly("tree", "google").inOrder();
    assertThat(tree.get("google")).containsExactly(6, 2).inOrder();

    TreeMultimap<String, Integer> copy = TreeMultimap.create(tree);
    assertEquals(tree, copy);
    assertThat(copy.keySet()).containsExactly("google", "tree").inOrder();
    assertThat(copy.get("google")).containsExactly(2, 6).inOrder();

  static final Tree c = new Tree('c');
  static final Tree d = new Tree('d', a, b, c);
  static final Tree e = new Tree('e');
  static final Tree f = new Tree('f');
  static final Tree g = new Tree('g', f);
  static final Tree h = new Tree('h', d, e, g);

  static String iterationOrder(Iterable<? extends Node> iterable) {
    StringBuilder builder = new StringBuilder();
    for (Node t : iterable) {

    /**
     * construct graph from a "dirty" tree
     */
    public MetadataGraph(MetadataTreeNode tree) throws MetadataResolutionException {
        this(tree, false, false);
    }
    // ------------------------------------------------------------------------
    /**
     * construct graph from a "dirty" tree
     *
     * @param tree "dirty" tree root

- github.com/containerd/continuity: [v0.1.0](https://github.com/containerd/continuity/tree/v0.1.0)
- github.com/containerd/fifo: [v1.0.0](https://github.com/containerd/fifo/tree/v1.0.0)
- github.com/containerd/go-runc: [v1.0.0](https://github.com/containerd/go-runc/tree/v1.0.0)
- github.com/containerd/typeurl: [v1.0.2](https://github.com/containerd/typeurl/tree/v1.0.2)

### Build tree state

"Build tree" is another name for the build definition.
The "build tree state" holds the state for the entire build definition for a single build execution within a session.

The build tree state is managed by the `BuildTreeState` class.

  /**
   * A tree-shaped graph that looks as follows (all edges are directed facing downwards):
   *
   * {@snippet :
   *        h
   *       /|\
   *      / | \
   *     /  |  \
   *    d   e   g
   *   /|\      |
   *  / | \     |
   * a  b  c    f
   * }
   */
  private static final SuccessorsFunction<Character> TREE =

            return null;
        }

        MetadataTreeNode tree = null;
        MetadataTreeNode parent = null;

        for (ArtifactMetadata md : classpath) {
            MetadataTreeNode node = new MetadataTreeNode(md, parent, md.isResolved(), md.getArtifactScope());
            if (tree == null) {
                tree = node;
            }

            if (parent != null) {

     * @param scope the {link PathScope} to collect dependencies, must not be {@code null}
     * @return the collection result, never {@code null}
     * @throws DependencyResolverException if the dependency tree could not be built
     * @throws IllegalArgumentException if an argument is null or invalid
     * @see #collect(DependencyResolverRequest)
     */
    @Nonnull
    default DependencyResolverResult collect(

import java.util.Collection;

/**
 * This is the main graph data structure used by the RepositorySystem to present tree and graph objects.
 *
 *
 */
@Deprecated
public class MetadataGraph {
    /** all graph nodes */
    Collection<MetadataGraphNode> nodes;

    /** entry point for tree-like structures */
    MetadataGraphNode entry;

    public MetadataGraph(MetadataGraphNode entry) {
        this();

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * metadata [dirty] Tree
 *
 *
 */
@Deprecated
public class MetadataTreeNode {
    ArtifactMetadata md; // this node

    MetadataTreeNode parent; // papa

    /** default # of children. Used for tree creation optimization only */
    int nChildren = 8;

    MetadataTreeNode[] children; // of cause