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

  @Override
  @Test
  public void predecessors_checkReturnedSetMutability() {
    addNode(N2);

        }
      }

      for (E outEdge : sanityCheckSet(network.outEdges(node))) {
        assertThat(network.incidentEdges(node)).contains(outEdge);
        assertThat(network.inEdges(network.incidentNodes(outEdge).adjacentNode(node)))
            .contains(outEdge);
        if (network.isDirected()) {
          assertThat(network.incidentNodes(outEdge).source()).isEqualTo(node);
        }
      }
    }

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

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

  @Override
  @Test
  public void predecessors_checkReturnedSetMutability() {

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

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

  @Override
  @Test
  public void predecessors_checkReturnedSetMutability() {

    return delegate().incidentEdges(node);
  }

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

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

  @Override
  public EndpointPair<N> incidentNodes(E edge) {
    return delegate().incidentNodes(edge);
  }

  @Override
  public Set<E> adjacentEdges(E edge) {

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

  @Override
  @Test
  public void predecessors_checkReturnedSetMutability() {
    addNode(N2);

  }

  @Override
  public Set<E> edgesConnecting(N nodeU, N nodeV) {
    Set<E> outEdgesU = outEdges(nodeU);
    Set<E> inEdgesV = inEdges(nodeV);
    return nodePairInvalidatableSet(
        outEdgesU.size() <= inEdgesV.size()
            ? unmodifiableSet(Sets.filter(outEdgesU, connectedPredicate(nodeU, nodeV)))
            : unmodifiableSet(Sets.filter(inEdgesV, connectedPredicate(nodeV, nodeU))),

  }

  @Override
  public Set<E> edgesConnecting(N nodeU, N nodeV) {
    Set<E> outEdgesU = outEdges(nodeU);
    Set<E> inEdgesV = inEdges(nodeV);
    return nodePairInvalidatableSet(
        outEdgesU.size() <= inEdgesV.size()
            ? unmodifiableSet(Sets.filter(outEdgesU, connectedPredicate(nodeU, nodeV)))
            : unmodifiableSet(Sets.filter(inEdgesV, connectedPredicate(nodeV, nodeU))),

  public Set<E> incidentEdges() {
    return Collections.unmodifiableSet(incidentEdgeMap.keySet());
  }

  @Override
  public Set<E> inEdges() {
    return incidentEdges();
  }

  @Override
  public Set<E> outEdges() {
    return incidentEdges();
  }

  @Override
  public N adjacentNode(E edge) {
    // We're relying on callers to call this method only with an edge that's in the graph.

      }
    };
  }

  @Override
  public Set<E> inEdges() {
    return Collections.unmodifiableSet(inEdgeMap.keySet());
  }

  @Override
  public Set<E> outEdges() {
    return Collections.unmodifiableSet(outEdgeMap.keySet());
  }

  @Override
  public N adjacentNode(E edge) {
    // Since the reference node is defined to be 'source' for directed graphs,