expectedClosure.putEdge(N2, N1);
    expectedClosure.putEdge(N2, N2);
    expectedClosure.putEdge(N2, N3);
    expectedClosure.putEdge(N2, N4);
    expectedClosure.putEdge(N3, N1);
    expectedClosure.putEdge(N3, N2);
    expectedClosure.putEdge(N3, N3);
    expectedClosure.putEdge(N3, N4);
    expectedClosure.putEdge(N4, N1);
    expectedClosure.putEdge(N4, N2);
    expectedClosure.putEdge(N4, N3);
    expectedClosure.putEdge(N4, N4);

    addEdge(N1, N2, E12);
    assertThat(successors).containsExactlyElementsIn(network.successors(N1));
  }

  @Test
  public void edges_containsOrderMismatch() {
    addEdge(N1, N2, E12);
    EndpointPair<Integer> endpointsN1N2 = EndpointPair.unordered(N1, N2);
    EndpointPair<Integer> endpointsN2N1 = EndpointPair.unordered(N2, N1);
    assertThat(network.asGraph().edges()).doesNotContain(endpointsN1N2);

    putEdge(N1, N2);
    assertThat(graph.successors(N1)).containsExactly(N2);
    // Edge direction handled correctly
    assertThat(graph.successors(N2)).isEmpty();
  }

  @Test
  public void incidentEdges_oneEdge() {
    putEdge(N1, N2);
    EndpointPair<Integer> expectedEndpoints = EndpointPair.ordered(N1, N2);
    assertThat(graph.incidentEdges(N1)).containsExactly(expectedEndpoints);

    directedGraph.putEdge(N1, N2);
    containsExactlySanityCheck(edges, EndpointPair.ordered(N1, N2));

    directedGraph.putEdge(N2, N1);
    containsExactlySanityCheck(edges, EndpointPair.ordered(N1, N2), EndpointPair.ordered(N2, N1));

    directedGraph.removeEdge(N1, N2);
    directedGraph.removeEdge(N2, N1);
    containsExactlySanityCheck(edges);

    assertThrows(

    directedGraph.putEdge(N1, N2);
    containsExactlySanityCheck(edges, EndpointPair.ordered(N1, N2));

    directedGraph.putEdge(N2, N1);
    containsExactlySanityCheck(edges, EndpointPair.ordered(N1, N2), EndpointPair.ordered(N2, N1));

    directedGraph.removeEdge(N1, N2);
    directedGraph.removeEdge(N2, N1);
    containsExactlySanityCheck(edges);

    assertThrows(

    network.addEdge(N1, N2, E12);
    assertThat(networkForTest.edgesConnecting(N1, N2)).containsExactly(E12);
    assertThat(networkForTest.edgesConnecting(N1, N1)).containsExactly(E11);
  }

  @Test
  public void edgesConnecting_parallelEdges() {
    network.addEdge(N1, N2, E12);
    network.addEdge(N1, N2, E12_A);
    network.addEdge(N2, N1, E21);
    if (edgeType == EdgeType.DIRECTED) {

    assertThat(network.adjacentNodes(N2)).isEmpty();
    assertThat(network.predecessors(N2)).isEmpty();
    assertThat(network.successors(N2)).isEmpty();
    assertThat(network.incidentEdges(N2)).isEmpty();
    assertThat(network.inEdges(N2)).isEmpty();
    assertThat(network.outEdges(N2)).isEmpty();
    assertThat(network.adjacentNodes(N4)).isEmpty();
    assertThat(network.predecessors(N4)).isEmpty();

    assertThat(network.adjacentNodes(N2)).isEmpty();
    assertThat(network.predecessors(N2)).isEmpty();
    assertThat(network.successors(N2)).isEmpty();
    assertThat(network.incidentEdges(N2)).isEmpty();
    assertThat(network.inEdges(N2)).isEmpty();
    assertThat(network.outEdges(N2)).isEmpty();
    assertThat(network.adjacentNodes(N4)).isEmpty();
    assertThat(network.predecessors(N4)).isEmpty();

    assertThat(graph.predecessors(N2)).containsExactly(N1);
    assertThat(graphAsMutableGraph.removeEdge(N1, N2)).isTrue();
    assertThat(graphAsMutableGraph.removeEdge(N1, N2)).isFalse();
    assertThat(graph.successors(N1)).isEmpty();
    assertThat(graph.predecessors(N2)).isEmpty();
  }

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

    putEdge(N1, N2);

	return &pr, nil
}

type nopReadCloser struct {
	fn func()
}

func (n2 *nopReadCloser) Read(p []byte) (n int, err error) {
	panic("should not be called")
}

func (n2 *nopReadCloser) Close() error {
	if n2.fn != nil {
		n2.fn()
	}
	n2.fn = nil
	return nil