count = vertices.size() + vertices.size() / 2;
        }

        checkEdges(count);
    }

    private void checkEdges(int nEdges) {
        if (incidentEdges == null) {
            incidentEdges = new HashMap<>(nEdges);
        }
        if (excidentEdges == null) {
            excidentEdges = new HashMap<>(nEdges);
        }
    }

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

  @Test
  public void predecessors_oneEdge() {
    putEdge(N1, N2);

      }

      for (E incidentEdge : sanityCheckSet(network.incidentEdges(node))) {
        assertTrue(
            network.inEdges(node).contains(incidentEdge)
                || network.outEdges(node).contains(incidentEdge));
        assertThat(network.edges()).contains(incidentEdge);
        assertThat(network.incidentNodes(incidentEdge)).contains(node);
      }

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

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

  @Test
  public void predecessors_oneEdge() {
    putEdge(N1, N2);

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

  @Test
  public void predecessors_oneEdge() {
    putEdge(N1, N2);

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

  @Override
  @Test
  public void adjacentNodes_checkReturnedSetMutability() {

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

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

  @Override
  @Test
  public void adjacentNodes_checkReturnedSetMutability() {

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

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

  @Override
  @Test
  public void adjacentNodes_checkReturnedSetMutability() {

  /**
   * Returns the count of {@code node}'s {@link #incidentEdges(Object) incident edges}, counting
   * self-loops twice (equivalently, the number of times an edge touches {@code node}).
   *
   * <p>For directed networks, this is equal to {@code inDegree(node) + outDegree(node)}.
   *
   * <p>For undirected networks, this is equal to {@code incidentEdges(node).size()} + (number of
   * self-loops incident to {@code node}).

        ImmutableList.builder();
    int predecessorCount = 0;
    int successorCount = 0;

    for (EndpointPair<N> incidentEdge : incidentEdges) {
      if (incidentEdge.nodeU().equals(thisNode) && incidentEdge.nodeV().equals(thisNode)) {
        // incidentEdge is a self-loop

        adjacentNodeValues.put(thisNode, new PredAndSucc(successorNodeToValueFn.apply(thisNode)));