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 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) { } }
@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); }
@Test public void createDirected_expectedEdgeCount() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().expectedEdgeCount(EDGE_COUNT).build(); assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty(); }
@Test public void copyOfImmutableNetwork_optimized() { Network<String, String> network1 = ImmutableNetwork.copyOf(NetworkBuilder.directed().<String, String>build()); Network<String, String> network2 = ImmutableNetwork.copyOf(network1); assertThat(network2).isSameAs(network1); }
@Test public void createDirected_expectedNodeCount() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().expectedNodeCount(NODE_COUNT).build(); assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty(); }
@Test public void createDirected_multigraph() { MutableNetwork<Integer, String> directedMultigraph = NetworkBuilder.directed().allowsParallelEdges(true).build(); assertThat(directedMultigraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedMultigraph.addEdge(N1, N2, E12_A)).isTrue(); assertThat(directedMultigraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12, E12_A)); assertThat(directedMultigraph.edgesConnecting(N2, N1)).isEmpty(); }
@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 @SuppressWarnings("CheckReturnValue") public void forTree_acceptsDirectedNetwork() throws Exception { MutableNetwork<String, Integer> network = NetworkBuilder.directed().build(); network.addEdge("a", "b", 11); Traverser.forTree(network); // Does not throw }
@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 edgeOrder_sorted() { MutableNetwork<Integer, String> network = NetworkBuilder.directed() .edgeOrder(ElementOrder.sorted(Ordering.<String>natural().reverse())) .build(); addEdges(network); assertThat(network.edgeOrder()) .isEqualTo(ElementOrder.sorted(Ordering.<String>natural().reverse())); assertThat(network.edges()).containsExactly("p", "i", "e").inOrder(); assertThat(network.nodeOrder()).isEqualTo(ElementOrder.insertion()); // default }
@Test public void edgesConnecting_directed() { MutableNetwork<String, String> mutableNetwork = NetworkBuilder.directed().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")).isEmpty(); }
@Test public void edgeOrder_natural() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(ElementOrder.<String>natural()).build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.sorted(Ordering.<String>natural())); assertThat(network.edges()).containsExactly("e", "i", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(insertion()); // default }
@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"); } }
@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 equivalent_propertiesDiffer() { network.addEdge(N1, N2, E12); MutableNetwork<Integer, String> g2 = NetworkBuilder.from(network) .allowsParallelEdges(!network.allowsParallelEdges()) .allowsSelfLoops(!network.allowsSelfLoops()) .build(); g2.addEdge(N1, N2, E12); assertThat(network).isEqualTo(g2); }
private static MutableNetwork<Integer, String> buildDirectedNetwork() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().allowsParallelEdges(true).allowsSelfLoops(true).build(); directedGraph.addEdge(N1, N1, E11); directedGraph.addEdge(N1, N2, E12); directedGraph.addEdge(N1, N1, E11_A); directedGraph.addEdge(N1, N2, E12_A); directedGraph.addEdge(N2, N1, E21); return directedGraph; }
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; } }