1 /* 2 * Copyright (C) 2014 The Guava Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.google.common.graph; 18 19 import static com.google.common.truth.Truth.assertThat; 20 import static org.junit.Assert.fail; 21 22 import com.google.common.collect.ImmutableSet; 23 import org.junit.Test; 24 import org.junit.runner.RunWith; 25 import org.junit.runners.JUnit4; 26 27 /** Tests for a directed {@link ConfigurableMutableNetwork} allowing self-loops. */ 28 @RunWith(JUnit4.class) 29 public class ConfigurableDirectedNetworkTest extends ConfigurableSimpleDirectedNetworkTest { 30 31 @Override createGraph()32 public MutableNetwork<Integer, String> createGraph() { 33 return NetworkBuilder.directed().allowsSelfLoops(true).build(); 34 } 35 36 @Test edges_selfLoop()37 public void edges_selfLoop() { 38 addEdge(N1, N1, E11); 39 assertThat(network.edges()).containsExactly(E11); 40 } 41 42 @Test incidentEdges_selfLoop()43 public void incidentEdges_selfLoop() { 44 addEdge(N1, N1, E11); 45 assertThat(network.incidentEdges(N1)).containsExactly(E11); 46 } 47 48 @Test incidentNodes_selfLoop()49 public void incidentNodes_selfLoop() { 50 addEdge(N1, N1, E11); 51 assertThat(network.incidentNodes(E11).source()).isEqualTo(N1); 52 assertThat(network.incidentNodes(E11).target()).isEqualTo(N1); 53 } 54 55 @Test adjacentNodes_selfLoop()56 public void adjacentNodes_selfLoop() { 57 addEdge(N1, N1, E11); 58 addEdge(N1, N2, E12); 59 assertThat(network.adjacentNodes(N1)).containsExactly(N1, N2); 60 } 61 62 @Test adjacentEdges_selfLoop()63 public void adjacentEdges_selfLoop() { 64 addEdge(N1, N1, E11); 65 addEdge(N1, N2, E12); 66 assertThat(network.adjacentEdges(E11)).containsExactly(E12); 67 } 68 69 @Test edgesConnecting_selfLoop()70 public void edgesConnecting_selfLoop() { 71 addEdge(N1, N1, E11); 72 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); 73 addEdge(N1, N2, E12); 74 assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12); 75 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); 76 } 77 78 @Test inEdges_selfLoop()79 public void inEdges_selfLoop() { 80 addEdge(N1, N1, E11); 81 assertThat(network.inEdges(N1)).containsExactly(E11); 82 addEdge(N4, N1, E41); 83 assertThat(network.inEdges(N1)).containsExactly(E11, E41); 84 } 85 86 @Test outEdges_selfLoop()87 public void outEdges_selfLoop() { 88 addEdge(N1, N1, E11); 89 assertThat(network.outEdges(N1)).containsExactly(E11); 90 addEdge(N1, N2, E12); 91 assertThat(network.outEdges(N1)).containsExactly(E11, E12); 92 } 93 94 @Test predecessors_selfLoop()95 public void predecessors_selfLoop() { 96 addEdge(N1, N1, E11); 97 assertThat(network.predecessors(N1)).containsExactly(N1); 98 addEdge(N4, N1, E41); 99 assertThat(network.predecessors(N1)).containsExactly(N1, N4); 100 } 101 102 @Test successors_selfLoop()103 public void successors_selfLoop() { 104 addEdge(N1, N1, E11); 105 assertThat(network.successors(N1)).containsExactly(N1); 106 addEdge(N1, N2, E12); 107 assertThat(network.successors(N1)).containsExactly(N1, N2); 108 } 109 110 @Test source_selfLoop()111 public void source_selfLoop() { 112 addEdge(N1, N1, E11); 113 assertThat(network.incidentNodes(E11).source()).isEqualTo(N1); 114 } 115 116 @Test target_selfLoop()117 public void target_selfLoop() { 118 addEdge(N1, N1, E11); 119 assertThat(network.incidentNodes(E11).target()).isEqualTo(N1); 120 } 121 122 @Test degree_selfLoop()123 public void degree_selfLoop() { 124 addEdge(N1, N1, E11); 125 assertThat(network.degree(N1)).isEqualTo(2); 126 addEdge(N1, N2, E12); 127 assertThat(network.degree(N1)).isEqualTo(3); 128 } 129 130 @Test inDegree_selfLoop()131 public void inDegree_selfLoop() { 132 addEdge(N1, N1, E11); 133 assertThat(network.inDegree(N1)).isEqualTo(1); 134 addEdge(N4, N1, E41); 135 assertThat(network.inDegree(N1)).isEqualTo(2); 136 } 137 138 @Test outDegree_selfLoop()139 public void outDegree_selfLoop() { 140 addEdge(N1, N1, E11); 141 assertThat(network.outDegree(N1)).isEqualTo(1); 142 addEdge(N1, N2, E12); 143 assertThat(network.outDegree(N1)).isEqualTo(2); 144 } 145 146 @Override 147 @Test addEdge_selfLoop()148 public void addEdge_selfLoop() { 149 assertThat(addEdge(N1, N1, E11)).isTrue(); 150 assertThat(network.edges()).contains(E11); 151 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); 152 } 153 154 @Test addEdge_existingSelfLoopEdgeBetweenSameNodes()155 public void addEdge_existingSelfLoopEdgeBetweenSameNodes() { 156 addEdge(N1, N1, E11); 157 ImmutableSet<String> edges = ImmutableSet.copyOf(network.edges()); 158 assertThat(addEdge(N1, N1, E11)).isFalse(); 159 assertThat(network.edges()).containsExactlyElementsIn(edges); 160 } 161 162 @Test addEdge_existingEdgeBetweenDifferentNodes_selfLoops()163 public void addEdge_existingEdgeBetweenDifferentNodes_selfLoops() { 164 addEdge(N1, N1, E11); 165 try { 166 addEdge(N1, N2, E11); 167 fail("Reusing an existing self-loop edge to connect different nodes succeeded"); 168 } catch (IllegalArgumentException e) { 169 assertThat(e.getMessage()).contains(ERROR_REUSE_EDGE); 170 } 171 try { 172 addEdge(N2, N2, E11); 173 fail("Reusing an existing self-loop edge to make a different self-loop edge succeeded"); 174 } catch (IllegalArgumentException e) { 175 assertThat(e.getMessage()).contains(ERROR_REUSE_EDGE); 176 } 177 addEdge(N1, N2, E12); 178 try { 179 addEdge(N1, N1, E12); 180 fail("Reusing an existing edge to add a self-loop edge between different nodes succeeded"); 181 } catch (IllegalArgumentException e) { 182 assertThat(e.getMessage()).contains(ERROR_REUSE_EDGE); 183 } 184 } 185 186 @Test addEdge_parallelSelfLoopEdge()187 public void addEdge_parallelSelfLoopEdge() { 188 addEdge(N1, N1, E11); 189 try { 190 addEdge(N1, N1, EDGE_NOT_IN_GRAPH); 191 fail("Adding a parallel self-loop edge succeeded"); 192 } catch (IllegalArgumentException e) { 193 assertThat(e.getMessage()).contains(ERROR_PARALLEL_EDGE); 194 } 195 } 196 197 @Test removeNode_existingNodeWithSelfLoopEdge()198 public void removeNode_existingNodeWithSelfLoopEdge() { 199 addNode(N1); 200 addEdge(N1, N1, E11); 201 assertThat(network.removeNode(N1)).isTrue(); 202 assertThat(network.nodes()).isEmpty(); 203 assertThat(network.edges()).doesNotContain(E11); 204 } 205 206 @Test removeEdge_existingSelfLoopEdge()207 public void removeEdge_existingSelfLoopEdge() { 208 addEdge(N1, N1, E11); 209 assertThat(network.removeEdge(E11)).isTrue(); 210 assertThat(network.edges()).doesNotContain(E11); 211 assertThat(network.edgesConnecting(N1, N1)).isEmpty(); 212 } 213 } 214