graph.addNode(node4);
    graph.addNode(node2);
    graph.addNode(node6);
    graph.addNode(node8);

    assertThat(graph.nodeOrder().comparator()).isEqualTo(Ordering.natural());
    assertThat(graph.nodes()).containsExactly(node2, node4, node6, node8).inOrder();
  }

  private static void addNodes(MutableGraph<Integer> graph) {
    graph.addNode(3);
    graph.addNode(1);

     *
     * @return this {@code Builder} object
     */
    @CanIgnoreReturnValue
    public Builder<N> addNode(N node) {
      mutableGraph.addNode(node);
      return this;
    }

    /**
     * Adds an edge connecting {@code nodeU} to {@code nodeV} if one is not already present.
     *

        List<BuildStep> firsts =
                add.values().stream().filter(b -> b.predecessors.isEmpty()).toList();
        firsts.stream()
                .filter(addNode -> !org.containsKey(addNode.name))
                .forEach(addNode -> lasts.forEach(orgNode -> addNode.executeAfter(orgNode)));
        add.forEach((name, node) -> org.merge(name, node, this::merge));
        return org;
    }

      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");

    assertThrows(UnsupportedOperationException.class, () -> nodes.add(N2));
    addNode(N1);
    assertThat(graph.nodes()).containsExactlyElementsIn(nodes);
  }

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

    addNode(N1);
    Set<Integer> adjacentNodes = graph.adjacentNodes(N1);

  }

  @Test
  public void edgesConnecting_disconnectedNodes() {
    network.addNode(N1);
    network.addNode(N2);
    assertThat(networkForTest.edgesConnecting(N1, N2)).isEmpty();
  }

  @Test
  public void edgesConnecting_nodesNotInGraph() {
    network.addNode(N1);
    network.addNode(N2);
    IllegalArgumentException e =
        assertThrows(
            IllegalArgumentException.class,

      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);

    assertThrows(UnsupportedOperationException.class, () -> nodes.add(N2));
    addNode(N1);
    assertThat(graph.nodes()).containsExactlyElementsIn(nodes);
  }

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

    addNode(N1);
    Set<Integer> adjacentNodes = graph.adjacentNodes(N1);

     *
     * @return this {@code Builder} object
     */
    @CanIgnoreReturnValue
    public ImmutableNetwork.Builder<N, E> addNode(N node) {
      mutableNetwork.addNode(node);
      return this;
    }

    /**
     * Adds {@code edge} connecting {@code nodeU} to {@code nodeV}.
     *

    }
  }

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

    addNode(N1);
    addNode(N2);
    Set<String> edgesConnecting = network.edgesConnecting(N1, N2);
    assertThrows(UnsupportedOperationException.class, () -> edgesConnecting.add(E23));
    addEdge(N1, N2, E12);