@Test public void nodes_noNodes() { assertThat(network.nodes()).isEmpty(); }
@Test public void nodes_oneNode() { addNode(N1); assertThat(network.nodes()).containsExactly(N1); }
/** * Returns the subgraph of {@code network} induced by {@code nodes}. This subgraph is a new graph * that contains all of the nodes in {@code nodes}, and all of the {@link Network#edges() edges} * from {@code network} for which the {@link Network#incidentNodes(Object) incident nodes} are * both contained by {@code nodes}. * * @throws IllegalArgumentException if any element in {@code nodes} is not a node in the graph */ public static <N, E> MutableNetwork<N, E> inducedSubgraph( Network<N, E> network, Iterable<? extends N> nodes) { MutableNetwork<N, E> subgraph = (nodes instanceof Collection) ? NetworkBuilder.from(network).expectedNodeCount(((Collection) nodes).size()).build() : NetworkBuilder.from(network).build(); for (N node : nodes) { subgraph.addNode(node); } for (N node : subgraph.nodes()) { for (E edge : network.outEdges(node)) { N successorNode = network.incidentNodes(edge).adjacentNode(node); if (subgraph.nodes().contains(successorNode)) { subgraph.addEdge(node, successorNode, edge); } } } return subgraph; }
@Test public void addNode_newNode() { assertTrue(addNode(N1)); assertThat(network.nodes()).contains(N1); }
@Test public void removeNode_existingNodeWithSelfLoopEdge() { addNode(N1); addEdge(N1, N1, E11); assertThat(network.removeNode(N1)).isTrue(); assertThat(network.nodes()).isEmpty(); assertThat(network.edges()).doesNotContain(E11); }
@Test public void removeNode_existingNodeWithSelfLoopEdge() { addNode(N1); addEdge(N1, N1, E11); assertThat(network.removeNode(N1)).isTrue(); assertThat(network.nodes()).isEmpty(); assertThat(network.edges()).doesNotContain(E11); }
/** Creates a mutable copy of {@code graph} with the same nodes, edges, and edge values. */ public static <N, V> MutableValueGraph<N, V> copyOf(ValueGraph<N, V> graph) { MutableValueGraph<N, V> copy = ValueGraphBuilder.from(graph).expectedNodeCount(graph.nodes().size()).build(); for (N node : graph.nodes()) { copy.addNode(node); } for (EndpointPair<N> edge : graph.edges()) { copy.putEdgeValue( edge.nodeU(), edge.nodeV(), graph.edgeValueOrDefault(edge.nodeU(), edge.nodeV(), null)); } return copy; }
@Test public void createDirected() { MutableNetwork<Integer, String> directedGraph = NetworkBuilder.directed().build(); assertThat(directedGraph.nodes()).isEmpty(); assertThat(directedGraph.edges()).isEmpty(); assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue(); assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12)); assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty(); // By default, parallel edges are not allowed. try { directedGraph.addEdge(N1, N2, E12_A); fail(ERROR_ADDED_PARALLEL_EDGE); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_PARALLEL_EDGE); } // By default, self-loop edges are not allowed. try { directedGraph.addEdge(N1, N1, E11); fail(ERROR_ADDED_SELF_LOOP); } catch (IllegalArgumentException e) { assertThat(e.getMessage()).contains(ERROR_SELF_LOOP); } }
@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); } }
@Test public void removeNode_existingNode() { addEdge(N1, N2, E12); addEdge(N4, N1, E41); assertTrue(network.removeNode(N1)); assertFalse(network.removeNode(N1)); assertThat(network.nodes()).containsExactly(N2, N4); assertThat(network.edges()).doesNotContain(E12); assertThat(network.edges()).doesNotContain(E41); }
@Test public void nodeOrderUnorderedandEdgesSorted() { MutableNetwork<Integer, String> network = NetworkBuilder.directed() .nodeOrder(unordered()) .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(unordered()); assertThat(network.nodes()).containsExactly(4, 1, 3); }
@After public void validateSourceAndTarget() { for (Integer node : network.nodes()) { for (String inEdge : network.inEdges(node)) { EndpointPair<Integer> endpointPair = network.incidentNodes(inEdge); assertThat(endpointPair.source()).isEqualTo(endpointPair.adjacentNode(node)); assertThat(endpointPair.target()).isEqualTo(node); } for (String outEdge : network.outEdges(node)) { EndpointPair<Integer> endpointPair = network.incidentNodes(outEdge); assertThat(endpointPair.source()).isEqualTo(node); assertThat(endpointPair.target()).isEqualTo(endpointPair.adjacentNode(node)); } for (Integer adjacentNode : network.adjacentNodes(node)) { Set<String> edges = network.edgesConnecting(node, adjacentNode); Set<String> antiParallelEdges = network.edgesConnecting(adjacentNode, node); assertThat(node.equals(adjacentNode) || Collections.disjoint(edges, antiParallelEdges)) .isTrue(); } } }
/** * This test checks an implementation dependent feature. It tests that the method {@code addEdge} * will silently add the missing nodes to the graph, then add the edge connecting them. We are not * using the proxy methods here as we want to test {@code addEdge} when the end-points are not * elements of the graph. */ @Test public void addEdge_nodesNotInGraph() { network.addNode(N1); assertTrue(network.addEdge(N1, N5, E15)); assertTrue(network.addEdge(N4, N1, E41)); assertTrue(network.addEdge(N2, N3, E23)); assertThat(network.nodes()).containsExactly(N1, N5, N4, N2, N3).inOrder(); assertThat(network.edges()).containsExactly(E15, E41, E23).inOrder(); assertThat(network.edgesConnecting(N1, N5)).containsExactly(E15); assertThat(network.edgesConnecting(N4, N1)).containsExactly(E41); assertThat(network.edgesConnecting(N2, N3)).containsExactly(E23); assertThat(network.edgesConnecting(N3, N2)).containsExactly(E23); } }
/** * This test checks an implementation dependent feature. It tests that the method {@code addEdge} * will silently add the missing nodes to the graph, then add the edge connecting them. We are not * using the proxy methods here as we want to test {@code addEdge} when the end-points are not * elements of the graph. */ @Test public void addEdge_nodesNotInGraph() { network.addNode(N1); assertTrue(network.addEdge(N1, N5, E15)); assertTrue(network.addEdge(N4, N1, E41)); assertTrue(network.addEdge(N2, N3, E23)); assertThat(network.nodes()).containsExactly(N1, N5, N4, N2, N3).inOrder(); assertThat(network.edges()).containsExactly(E15, E41, E23).inOrder(); assertThat(network.edgesConnecting(N1, N5)).containsExactly(E15); assertThat(network.edgesConnecting(N4, N1)).containsExactly(E41); assertThat(network.edgesConnecting(N2, N3)).containsExactly(E23); // Direction of the added edge is correctly handled assertThat(network.edgesConnecting(N3, N2)).isEmpty(); } }
assertThat(transpose.edgeConnectingOrNull(N1, N2)).isNull(); for (Integer node : directedGraph.nodes()) { assertThat(directedGraph.inDegree(node)).isSameAs(transpose.outDegree(node)); assertThat(directedGraph.outDegree(node)).isSameAs(transpose.inDegree(node));
@After public void validateUndirectedEdges() { for (Integer node : network.nodes()) { new EqualsTester() .addEqualityGroup( network.inEdges(node), network.outEdges(node), network.incidentEdges(node)) .testEquals(); new EqualsTester() .addEqualityGroup( network.predecessors(node), network.successors(node), network.adjacentNodes(node)) .testEquals(); for (Integer adjacentNode : network.adjacentNodes(node)) { assertThat(network.edgesConnecting(node, adjacentNode)) .containsExactlyElementsIn(network.edgesConnecting(adjacentNode, node)); } } }