{true, ElementOrder.stable()},
        });
  }

  private final boolean allowsSelfLoops;
  private final ElementOrder<Integer> incidentEdgeOrder;

  public StandardMutableDirectedGraphTest(
      boolean allowsSelfLoops, ElementOrder<Integer> incidentEdgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;
    this.incidentEdgeOrder = incidentEdgeOrder;
  }

  @Override

          {true, ElementOrder.stable()},
        });
  }

  private final boolean allowsSelfLoops;
  private final ElementOrder<Integer> incidentEdgeOrder;

  public StandardMutableDirectedGraphTest(
      boolean allowsSelfLoops, ElementOrder<Integer> incidentEdgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;
    this.incidentEdgeOrder = incidentEdgeOrder;
  }

  @Override

    this.allowsSelfLoops = allowsSelfLoops;
    this.allowsParallelEdges = allowsParallelEdges;
    this.nodeOrder = nodeOrder;
    this.edgeOrder = edgeOrder;
  }

  @Override
  MutableNetwork<Integer, String> createGraph() {
    return NetworkBuilder.directed()
        .allowsSelfLoops(allowsSelfLoops)
        .allowsParallelEdges(allowsParallelEdges)
        .nodeOrder(nodeOrder)
        .edgeOrder(edgeOrder)
        .build();

    this.allowsSelfLoops = allowsSelfLoops;
    this.allowsParallelEdges = allowsParallelEdges;
    this.nodeOrder = nodeOrder;
    this.edgeOrder = edgeOrder;
  }

  @Override
  MutableNetwork<Integer, String> createGraph() {
    return NetworkBuilder.undirected()
        .allowsSelfLoops(allowsSelfLoops)
        .allowsParallelEdges(allowsParallelEdges)
        .nodeOrder(nodeOrder)
        .edgeOrder(edgeOrder)
        .build();

    this.allowsSelfLoops = allowsSelfLoops;
    this.allowsParallelEdges = allowsParallelEdges;
    this.nodeOrder = nodeOrder;
    this.edgeOrder = edgeOrder;
  }

  @Override
  MutableNetwork<Integer, String> createGraph() {
    return NetworkBuilder.directed()
        .allowsSelfLoops(allowsSelfLoops)
        .allowsParallelEdges(allowsParallelEdges)
        .nodeOrder(nodeOrder)
        .edgeOrder(edgeOrder)
        .build();

      ElementOrder<String> edgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;
    this.allowsParallelEdges = allowsParallelEdges;
    this.nodeOrder = nodeOrder;
    this.edgeOrder = edgeOrder;
  }

  @Override
  Network<Integer, String> createGraph() {
    networkBuilder =
        NetworkBuilder.directed()
            .allowsSelfLoops(allowsSelfLoops)
            .allowsParallelEdges(allowsParallelEdges)

   *     nodeV}, or null if there was no such edge.
   * @throws IllegalArgumentException if the introduction of the edge would violate {@link
   *     #allowsSelfLoops()}
   */
  @CanIgnoreReturnValue
  @Nullable V putEdgeValue(N nodeU, N nodeV, V value);

  /**
   * Adds an edge connecting {@code endpoints} if one is not already present, and sets a value for

    return delegate().isDirected();
  }

  @Override
  public boolean allowsParallelEdges() {
    return delegate().allowsParallelEdges();
  }

  @Override
  public boolean allowsSelfLoops() {
    return delegate().allowsSelfLoops();
  }

  @Override
  public ElementOrder<N> nodeOrder() {
    return delegate().nodeOrder();
  }

  @Override
  public ElementOrder<E> edgeOrder() {

  @Override
  @CanIgnoreReturnValue
  public @Nullable V putEdgeValue(N nodeU, N nodeV, V value) {
    checkNotNull(nodeU, "nodeU");
    checkNotNull(nodeV, "nodeV");
    checkNotNull(value, "value");

    if (!allowsSelfLoops()) {
      checkArgument(!nodeU.equals(nodeV), SELF_LOOPS_NOT_ALLOWED, nodeU);
    }

    GraphConnections<N, V> connectionsU = nodeConnections.get(nodeU);
    if (connectionsU == null) {

   *
   * @return {@code true} if the graph was modified as a result of this call
   * @throws IllegalArgumentException if the introduction of the edge would violate {@link
   *     #allowsSelfLoops()}
   */
  @CanIgnoreReturnValue
  boolean putEdge(N nodeU, N nodeV);

  /**
   * Adds an edge connecting {@code endpoints} (in the order, if any, specified by {@code