@Test public void directedNetwork() { testNetworkMutation(NetworkBuilder.directed()); }
@Test public void builder_expectedNodeCount_negative() { try { NetworkBuilder.directed().expectedNodeCount(-1); fail("Should have rejected negative expected node count."); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_NEGATIVE_COUNT); } }
@Test public void builder_expectedEdgeCount_negative() { try { NetworkBuilder.directed().expectedEdgeCount(-1); fail("Should have rejected negative expected edge count."); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_NEGATIVE_COUNT); } }
private static <N> ImmutableNetwork<N, N> networkWithNode(N node) { MutableNetwork<N, N> network = NetworkBuilder.directed().build(); network.addNode(node); return ImmutableNetwork.copyOf(network); } }
@Override public MutableNetwork<Integer, String> createGraph() { return NetworkBuilder.directed().allowsParallelEdges(false).allowsSelfLoops(false).build(); }
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 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 @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 immutableNetwork() { MutableNetwork<String, Integer> mutableNetwork = NetworkBuilder.directed().build(); mutableNetwork.addNode("A"); ImmutableNetwork<String, Integer> immutableNetwork = ImmutableNetwork.copyOf(mutableNetwork); assertThat(immutableNetwork.asGraph()).isInstanceOf(ImmutableGraph.class); assertThat(immutableNetwork).isNotInstanceOf(MutableNetwork.class); assertThat(immutableNetwork).isEqualTo(mutableNetwork); mutableNetwork.addNode("B"); assertThat(immutableNetwork).isNotEqualTo(mutableNetwork); }
@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 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_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_default() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.insertion()); assertThat(network.edges()).containsExactly("i", "e", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(ElementOrder.insertion()); // default }
@Test public void edgeOrder_none() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(unordered()).build(); assertThat(network.edgeOrder()).isEqualTo(unordered()); assertThat(network.nodeOrder()).isEqualTo(insertion()); // default }
@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 edgeOrder_insertion() { MutableNetwork<Integer, String> network = NetworkBuilder.directed().edgeOrder(insertion()).build(); addEdges(network); assertThat(network.edgeOrder()).isEqualTo(ElementOrder.insertion()); assertThat(network.edges()).containsExactly("i", "e", "p").inOrder(); assertThat(network.nodeOrder()).isEqualTo(ElementOrder.insertion()); // default }
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; }