addEdge(N1, N2, E12);
    Set<Integer> n1AdjacentNodes = network.adjacentNodes(N1);
    Set<Integer> n2AdjacentNodes = network.adjacentNodes(N2);
    Set<Integer> n1Predecessors = network.predecessors(N1);
    Set<Integer> n2Predecessors = network.predecessors(N2);
    Set<Integer> n1Successors = network.successors(N1);
    Set<Integer> n2Successors = network.successors(N2);
    Set<String> n1IncidentEdges = network.incidentEdges(N1);

        }
        assertThat(
                graph.predecessors(node).contains(adjacentNode)
                    || graph.successors(node).contains(adjacentNode))
            .isTrue();
      }

      for (N predecessor : sanityCheckSet(graph.predecessors(node))) {
        assertThat(graph.successors(predecessor)).contains(node);
        assertThat(graph.hasEdgeConnecting(predecessor, node)).isTrue();

    assume().that(graphIsMutable()).isTrue();

    addNode(N2);
    Set<Integer> predecessors = graph.predecessors(N2);
    assertThrows(UnsupportedOperationException.class, () -> predecessors.add(N1));
    putEdge(N1, N2);
    assertThat(graph.predecessors(N2)).containsExactlyElementsIn(predecessors);
  }

  @Override
  @Test
  public void successors_checkReturnedSetMutability() {

    assume().that(graphIsMutable()).isTrue();

    addNode(N2);
    Set<Integer> predecessors = graph.predecessors(N2);
    assertThrows(UnsupportedOperationException.class, () -> predecessors.add(N1));
    putEdge(N1, N2);
    assertThat(graph.predecessors(N2)).containsExactlyElementsIn(predecessors);
  }

  @Override
  @Test
  public void successors_checkReturnedSetMutability() {

  /** Remove {@code node} from the set of predecessors. */
  void removePredecessor(N node);

  /**
   * Remove {@code node} from the set of successors. Returns the value previously associated with
   * the edge connecting the two nodes.
   */
  @CanIgnoreReturnValue
  @CheckForNull
  V removeSuccessor(N node);

  /**
   * Add {@code node} as a predecessor to the origin node. In the case of an undirected graph, it

 * which has a method {@code getParents()} that retrieves its predecessors in a graph:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, MyNode::getParents);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the predecessors of a node, or one that doesn't
 * return a {@code Iterable<? extends N>}, then you can use a lambda to perform a more general

    assume().that(graphIsMutable()).isTrue();

    addNode(N2);
    Set<Integer> predecessors = network.predecessors(N2);
    assertThrows(UnsupportedOperationException.class, () -> predecessors.add(N1));
    addEdge(N1, N2, E12);
    assertThat(network.predecessors(N2)).containsExactlyElementsIn(predecessors);
  }

  @Override
  @Test
  public void successors_checkReturnedSetMutability() {

    assume().that(graphIsMutable()).isTrue();

    addNode(N2);
    Set<Integer> predecessors = network.predecessors(N2);
    assertThrows(UnsupportedOperationException.class, () -> predecessors.add(N1));
    addEdge(N1, N2, E12);
    assertThat(network.predecessors(N2)).containsExactlyElementsIn(predecessors);
  }

  @Override
  @Test
  public void successors_checkReturnedSetMutability() {

  @Test
  public void predecessors_checkReturnedSetMutability() {
    addNode(N2);
    Set<Integer> predecessors = network.predecessors(N2);
    assertThrows(UnsupportedOperationException.class, () -> predecessors.add(N1));
    addEdge(N1, N2, E12);
    assertThat(network.predecessors(N2)).containsExactlyElementsIn(predecessors);
  }

  @Override
  @Test
  public void successors_checkReturnedSetMutability() {

    return delegate().incidentEdgeOrder();
  }

  @Override
  public Set<N> adjacentNodes(N node) {
    return delegate().adjacentNodes(node);
  }

  @Override
  public Set<N> predecessors(N node) {
    return delegate().predecessors(node);
  }

  @Override
  public Set<N> successors(N node) {
    return delegate().successors(node);
  }

  @Override
  public int degree(N node) {