@Test public void undirectedNetwork() { testNetworkMutation(NetworkBuilder.undirected()); }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsSelfLoops(true).build(); }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); }
@Test public void inducedSubgraph_nodeNotInGraph() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().build(); try { inducedSubgraph(undirectedGraph, ImmutableSet.of(N1)); fail("Should have rejected getting induced subgraph with node not in original graph."); } catch (IllegalArgumentException expected) { } }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.undirected().allowsParallelEdges(false).allowsSelfLoops(false).build(); }
@Test public void createUndirected_expectedNodeCount() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().expectedNodeCount(NODE_COUNT).build(); assertThat(undirectedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(undirectedGraph.edgesConnecting(N2, N1)).isEqualTo(ImmutableSet.of(E12)); }
@Test public void createUndirected_expectedEdgeCount() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().expectedEdgeCount(EDGE_COUNT).build(); assertThat(undirectedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(undirectedGraph.edgesConnecting(N2, N1)).isEqualTo(ImmutableSet.of(E12)); }
@Test public void transpose_undirectedNetwork() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().build(); undirectedGraph.addEdge(N1, N2, E12); assertThat(transpose(undirectedGraph)).isSameAs(undirectedGraph); }
private static MutableNetwork<Integer, String> createNetwork(EdgeType edgeType) { switch (edgeType) { case UNDIRECTED: return NetworkBuilder.undirected().allowsSelfLoops(true).build(); case DIRECTED: return NetworkBuilder.directed().allowsSelfLoops(true).build(); default: throw new IllegalStateException("Unexpected edge type: " + edgeType); } }
@Test public void createUndirected_multigraph() { MutableNetwork<Integer, String> undirectedMultigraph = NetworkBuilder.undirected().allowsParallelEdges(true).build(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(undirectedMultigraph.addEdge(N2, N1, E21)).isTrue(); assertThat(undirectedMultigraph.edgesConnecting(N1, N2)) .isEqualTo(ImmutableSet.of(E12, E12_A, E21)); }
@Test public void forTree_withUndirectedNetwork_throws() throws Exception { MutableNetwork<String, Integer> network = NetworkBuilder.undirected().build(); network.addEdge("a", "b", 11); try { Traverser.forTree(network); fail("Expected exception"); } catch (IllegalArgumentException expected) { } }
@Test public void edgesConnecting_undirected() { MutableNetwork<String, String> mutableNetwork = NetworkBuilder.undirected().allowsSelfLoops(true).build(); mutableNetwork.addEdge("A", "A", "AA"); mutableNetwork.addEdge("A", "B", "AB"); Network<String, String> network = ImmutableNetwork.copyOf(mutableNetwork); assertThat(network.edgesConnecting("A", "A")).containsExactly("AA"); assertThat(network.edgesConnecting("A", "B")).containsExactly("AB"); assertThat(network.edgesConnecting("B", "A")).containsExactly("AB"); } }
@Test public void createUndirected() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().build(); assertThat(undirectedGraph.nodes()).isEmpty(); assertThat(undirectedGraph.edges()).isEmpty(); assertThat(undirectedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(undirectedGraph.edgesConnecting(N2, N1)).isEqualTo(ImmutableSet.of(E12)); // By default, parallel edges are not allowed. try { undirectedGraph.addEdge(N1, N2, E12_A); fail(ERROR_ADDED_PARALLEL_EDGE); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_PARALLEL_EDGE); } try { undirectedGraph.addEdge(N2, N1, E21); fail(ERROR_ADDED_PARALLEL_EDGE); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_PARALLEL_EDGE); } // By default, self-loop edges are not allowed. try { undirectedGraph.addEdge(N1, N1, E11); fail(ERROR_ADDED_SELF_LOOP); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_SELF_LOOP); } }
@Before public void setUp() throws Exception { NetworkBuilder<Object, Object> builder = (edgeType == EdgeType.DIRECTED) ? NetworkBuilder.directed() : NetworkBuilder.undirected(); network = builder.allowsSelfLoops(true).allowsParallelEdges(true).build(); networkForTest = NetworkForTest.from(network); }
@Test public void testAdjacentNode_nodeNotIncident() { ImmutableList<MutableNetwork<Integer, String>> testNetworks = ImmutableList.of( NetworkBuilder.directed().<Integer, String>build(), NetworkBuilder.undirected().<Integer, String>build()); for (MutableNetwork<Integer, String> network : testNetworks) { network.addEdge(1, 2, "1-2"); EndpointPair<Integer> endpointPair = network.incidentNodes("1-2"); try { endpointPair.adjacentNode(3); fail("Should have rejected adjacentNode() called with a node not incident to edge."); } catch (IllegalArgumentException expected) { } } }
private static MutableNetwork<Integer, String> buildUndirectedNetwork() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); undirectedGraph.addEdge(N1, N1, E11); undirectedGraph.addEdge(N1, N2, E12); undirectedGraph.addEdge(N1, N1, E11_A); undirectedGraph.addEdge(N1, N2, E12_A); undirectedGraph.addEdge(N2, N1, E21); return undirectedGraph; } }
@Before public void init() { MutableGraph<Integer> mutableDirectedGraph = GraphBuilder.directed().allowsSelfLoops(true).build(); MutableGraph<Integer> mutableUndirectedGraph = GraphBuilder.undirected().allowsSelfLoops(true).build(); graphsToTest = ImmutableList.of(mutableDirectedGraph, mutableUndirectedGraph); directedGraph = mutableDirectedGraph; undirectedGraph = mutableUndirectedGraph; MutableNetwork<Integer, String> mutableDirectedNetwork = NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); MutableNetwork<Integer, String> mutableUndirectedNetwork = NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); networksToTest = ImmutableList.of(mutableDirectedNetwork, mutableUndirectedNetwork); directedNetwork = mutableDirectedNetwork; undirectedNetwork = mutableUndirectedNetwork; }
@Test public void endpointPair_undirectedNetwork() { MutableNetwork<Integer, String> undirectedNetwork = NetworkBuilder.undirected().allowsParallelEdges(true).allowsSelfLoops(true).build(); undirectedNetwork.addNode(N0); undirectedNetwork.addEdge(N1, N2, E12); undirectedNetwork.addEdge(N2, N1, E12_A); // adds parallel edge, won't be in Graph edges undirectedNetwork.addEdge(N1, N3, E13); undirectedNetwork.addEdge(N4, N4, E44); containsExactlySanityCheck( undirectedNetwork.asGraph().edges(), EndpointPair.unordered(N1, N2), EndpointPair.unordered(N1, N3), EndpointPair.unordered(N4, N4)); }
@Test public void transpose_undirectedNetwork() { MutableNetwork<Integer, String> undirectedGraph = NetworkBuilder.undirected().build(); undirectedGraph.addEdge(N1, N2, E12); assertThat(transpose(undirectedGraph)).isSameAs(undirectedGraph); }
@Test public void createUndirected_multigraph() { MutableNetwork<Integer, String> undirectedMultigraph = NetworkBuilder.undirected().allowsParallelEdges(true).build(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(undirectedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(undirectedMultigraph.addEdge(N2, N1, E21)).isTrue(); assertThat(undirectedMultigraph.edgesConnecting(N1, N2)) .isEqualTo(ImmutableSet.of(E12, E12_A, E21)); }