return GraphBuilder.undirected()
        .allowsSelfLoops(allowsSelfLoops)
        .incidentEdgeOrder(incidentEdgeOrder)
        .build();
  }

  @Override
  final void addNode(Integer n) {
    graphAsMutableGraph.addNode(n);
  }

  @Override
  final void putEdge(Integer n1, Integer n2) {
    graphAsMutableGraph.putEdge(n1, n2);
  }

    this.backingValueGraph = new StandardMutableValueGraph<>(builder);
  }

  @Override
  BaseGraph<N> delegate() {
    return backingValueGraph;
  }

  @Override
  public boolean addNode(N node) {
    return backingValueGraph.addNode(node);
  }

  @Override
  public boolean putEdge(N nodeU, N nodeV) {
    return backingValueGraph.putEdgeValue(nodeU, nodeV, Presence.EDGE_EXISTS) == null;
  }

  @Override

    public MetadataGraph(MetadataGraphNode entry) {
        this();

        this.entry = entry;
    }

    public MetadataGraph() {
        nodes = new ArrayList<>(64);
    }

    public void addNode(MetadataGraphNode node) {
        nodes.add(node);
    }

    /**
     * find a node by the GAV (metadata)
     *
     * @param md
     */
    public MetadataGraphNode findNode(MavenArtifactMetadata md) {

            .nodeOrder(nodeOrder)
            .edgeOrder(edgeOrder)
            .immutable();

    return networkBuilder.build();
  }

  @Override
  void addNode(Integer n) {
    networkBuilder.addNode(n);
    network = networkBuilder.build();
  }

  @Override
  void addEdge(Integer n1, Integer n2, String e) {
    networkBuilder.addEdge(n1, n2, e);
    network = networkBuilder.build();
  }

      NetworkBuilder.directed().<String, String>immutable().addNode("A").build();
  private static final ImmutableNetwork<String, String> IMMUTABLE_NETWORK_B =
      NetworkBuilder.directed().<String, String>immutable().addNode("B").build();

  public PackageSanityTests() {
    MutableNetwork<String, String> mutableNetworkA = NetworkBuilder.directed().build();
    mutableNetworkA.addNode("a");

        GraphBuilder.from(graph).allowsSelfLoops(true).<N>immutable();

    for (N node : graph.nodes()) {
      // add each node explicitly to include isolated nodes
      transitiveClosure.addNode(node);
      for (N reachableNode : getReachableNodes(graph, node, strategy)) {
        transitiveClosure.putEdge(node, reachableNode);
      }
    }
    return transitiveClosure.build();
  }

  /**

      assertThat(network.nodes()).isEmpty();
      assertThat(network.edges()).isEmpty();
      AbstractNetworkTest.validateNetwork(network);

      while (network.nodes().size() < NUM_NODES) {
        network.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(network.nodes());
      for (int i = 0; i < NUM_EDGES; ++i) {
        // Parallel edges are allowed, so this should always succeed.

      assertThat(graph.nodes()).isEmpty();
      assertThat(graph.edges()).isEmpty();
      AbstractGraphTest.validateGraph(graph);

      while (graph.nodes().size() < NUM_NODES) {
        graph.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(graph.nodes());
      while (graph.edges().size() < NUM_EDGES) {

    assertThat(graphAsMutableGraph.addNode(N1)).isTrue();
    assertThat(graph.nodes()).contains(N1);
  }

  @Test
  public void addNode_existingNode() {
    assume().that(graphIsMutable()).isTrue();

    addNode(N1);
    ImmutableSet<Integer> nodes = ImmutableSet.copyOf(graph.nodes());
    assertThat(graphAsMutableGraph.addNode(N1)).isFalse();

      assertThat(network.adjacentEdges(E12)).containsExactlyElementsIn(adjacentEdges);
    }
  }

  @Override
  @Test
  public void edgesConnecting_checkReturnedSetMutability() {
    addNode(N1);
    addNode(N2);
    Set<String> edgesConnecting = network.edgesConnecting(N1, N2);
    assertThrows(UnsupportedOperationException.class, () -> edgesConnecting.add(E23));
    addEdge(N1, N2, E12);