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.graph.GraphConstants.ENDPOINTS_MISMATCH; 20 import static com.google.common.truth.Truth.assertThat; 21 import static com.google.common.truth.TruthJUnit.assume; 22 import static org.junit.Assert.assertThrows; 23 import static org.junit.Assert.assertTrue; 24 import static org.junit.Assert.fail; 25 26 import com.google.common.collect.ImmutableSet; 27 import com.google.common.testing.EqualsTester; 28 import java.util.Optional; 29 import java.util.Set; 30 import org.junit.After; 31 import org.junit.Test; 32 33 /** 34 * Abstract base class for testing undirected {@link Network} implementations defined in this 35 * package. 36 */ 37 public abstract class AbstractStandardUndirectedNetworkTest extends AbstractNetworkTest { 38 private static final EndpointPair<Integer> ENDPOINTS_N1N2 = EndpointPair.ordered(N1, N2); 39 private static final EndpointPair<Integer> ENDPOINTS_N2N1 = EndpointPair.ordered(N2, N1); 40 41 @After validateUndirectedEdges()42 public void validateUndirectedEdges() { 43 for (Integer node : network.nodes()) { 44 new EqualsTester() 45 .addEqualityGroup( 46 network.inEdges(node), network.outEdges(node), network.incidentEdges(node)) 47 .testEquals(); 48 new EqualsTester() 49 .addEqualityGroup( 50 network.predecessors(node), network.successors(node), network.adjacentNodes(node)) 51 .testEquals(); 52 53 for (Integer adjacentNode : network.adjacentNodes(node)) { 54 assertThat(network.edgesConnecting(node, adjacentNode)) 55 .containsExactlyElementsIn(network.edgesConnecting(adjacentNode, node)); 56 } 57 } 58 } 59 60 @Override 61 @Test nodes_checkReturnedSetMutability()62 public void nodes_checkReturnedSetMutability() { 63 Set<Integer> nodes = network.nodes(); 64 assertThrows(UnsupportedOperationException.class, () -> nodes.add(N2)); 65 addNode(N1); 66 assertThat(network.nodes()).containsExactlyElementsIn(nodes); 67 } 68 69 @Override 70 @Test edges_checkReturnedSetMutability()71 public void edges_checkReturnedSetMutability() { 72 Set<String> edges = network.edges(); 73 assertThrows(UnsupportedOperationException.class, () -> edges.add(E12)); 74 addEdge(N1, N2, E12); 75 assertThat(network.edges()).containsExactlyElementsIn(edges); 76 } 77 78 @Override 79 @Test incidentEdges_checkReturnedSetMutability()80 public void incidentEdges_checkReturnedSetMutability() { 81 addNode(N1); 82 Set<String> incidentEdges = network.incidentEdges(N1); 83 assertThrows(UnsupportedOperationException.class, () -> incidentEdges.add(E12)); 84 addEdge(N1, N2, E12); 85 assertThat(network.incidentEdges(N1)).containsExactlyElementsIn(incidentEdges); 86 } 87 88 @Override 89 @Test adjacentNodes_checkReturnedSetMutability()90 public void adjacentNodes_checkReturnedSetMutability() { 91 addNode(N1); 92 Set<Integer> adjacentNodes = network.adjacentNodes(N1); 93 assertThrows(UnsupportedOperationException.class, () -> adjacentNodes.add(N2)); 94 addEdge(N1, N2, E12); 95 assertThat(network.adjacentNodes(N1)).containsExactlyElementsIn(adjacentNodes); 96 } 97 98 @Override adjacentEdges_checkReturnedSetMutability()99 public void adjacentEdges_checkReturnedSetMutability() { 100 addEdge(N1, N2, E12); 101 Set<String> adjacentEdges = network.adjacentEdges(E12); 102 try { 103 adjacentEdges.add(E23); 104 fail(ERROR_MODIFIABLE_COLLECTION); 105 } catch (UnsupportedOperationException e) { 106 addEdge(N2, N3, E23); 107 assertThat(network.adjacentEdges(E12)).containsExactlyElementsIn(adjacentEdges); 108 } 109 } 110 111 @Override 112 @Test edgesConnecting_checkReturnedSetMutability()113 public void edgesConnecting_checkReturnedSetMutability() { 114 addNode(N1); 115 addNode(N2); 116 Set<String> edgesConnecting = network.edgesConnecting(N1, N2); 117 assertThrows(UnsupportedOperationException.class, () -> edgesConnecting.add(E23)); 118 addEdge(N1, N2, E12); 119 assertThat(network.edgesConnecting(N1, N2)).containsExactlyElementsIn(edgesConnecting); 120 } 121 122 @Override 123 @Test inEdges_checkReturnedSetMutability()124 public void inEdges_checkReturnedSetMutability() { 125 addNode(N2); 126 Set<String> inEdges = network.inEdges(N2); 127 assertThrows(UnsupportedOperationException.class, () -> inEdges.add(E12)); 128 addEdge(N1, N2, E12); 129 assertThat(network.inEdges(N2)).containsExactlyElementsIn(inEdges); 130 } 131 132 @Override 133 @Test outEdges_checkReturnedSetMutability()134 public void outEdges_checkReturnedSetMutability() { 135 addNode(N1); 136 Set<String> outEdges = network.outEdges(N1); 137 assertThrows(UnsupportedOperationException.class, () -> outEdges.add(E12)); 138 addEdge(N1, N2, E12); 139 assertThat(network.outEdges(N1)).containsExactlyElementsIn(outEdges); 140 } 141 142 @Override 143 @Test predecessors_checkReturnedSetMutability()144 public void predecessors_checkReturnedSetMutability() { 145 addNode(N2); 146 Set<Integer> predecessors = network.predecessors(N2); 147 assertThrows(UnsupportedOperationException.class, () -> predecessors.add(N1)); 148 addEdge(N1, N2, E12); 149 assertThat(network.predecessors(N2)).containsExactlyElementsIn(predecessors); 150 } 151 152 @Override 153 @Test successors_checkReturnedSetMutability()154 public void successors_checkReturnedSetMutability() { 155 addNode(N1); 156 Set<Integer> successors = network.successors(N1); 157 assertThrows(UnsupportedOperationException.class, () -> successors.add(N2)); 158 addEdge(N1, N2, E12); 159 assertThat(network.successors(N1)).containsExactlyElementsIn(successors); 160 } 161 162 @Test edges_containsOrderMismatch()163 public void edges_containsOrderMismatch() { 164 addEdge(N1, N2, E12); 165 assertThat(network.asGraph().edges()).doesNotContain(ENDPOINTS_N2N1); 166 assertThat(network.asGraph().edges()).doesNotContain(ENDPOINTS_N1N2); 167 } 168 169 @Test edgesConnecting_orderMismatch()170 public void edgesConnecting_orderMismatch() { 171 addEdge(N1, N2, E12); 172 IllegalArgumentException e = 173 assertThrows( 174 IllegalArgumentException.class, 175 () -> { 176 Set<String> unused = network.edgesConnecting(ENDPOINTS_N1N2); 177 }); 178 assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH); 179 } 180 181 @Test edgeConnecting_orderMismatch()182 public void edgeConnecting_orderMismatch() { 183 addEdge(N1, N2, E12); 184 IllegalArgumentException e = 185 assertThrows( 186 IllegalArgumentException.class, 187 () -> { 188 Optional<String> unused = network.edgeConnecting(ENDPOINTS_N1N2); 189 }); 190 assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH); 191 } 192 193 @Test edgeConnectingOrNull_orderMismatch()194 public void edgeConnectingOrNull_orderMismatch() { 195 addEdge(N1, N2, E12); 196 IllegalArgumentException e = 197 assertThrows( 198 IllegalArgumentException.class, 199 () -> { 200 String unused = network.edgeConnectingOrNull(ENDPOINTS_N1N2); 201 }); 202 assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH); 203 } 204 205 @Test edgesConnecting_oneEdge()206 public void edgesConnecting_oneEdge() { 207 addEdge(N1, N2, E12); 208 assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12); 209 assertThat(network.edgesConnecting(N2, N1)).containsExactly(E12); 210 } 211 212 @Test inEdges_oneEdge()213 public void inEdges_oneEdge() { 214 addEdge(N1, N2, E12); 215 assertThat(network.inEdges(N2)).containsExactly(E12); 216 assertThat(network.inEdges(N1)).containsExactly(E12); 217 } 218 219 @Test outEdges_oneEdge()220 public void outEdges_oneEdge() { 221 addEdge(N1, N2, E12); 222 assertThat(network.outEdges(N2)).containsExactly(E12); 223 assertThat(network.outEdges(N1)).containsExactly(E12); 224 } 225 226 @Test predecessors_oneEdge()227 public void predecessors_oneEdge() { 228 addEdge(N1, N2, E12); 229 assertThat(network.predecessors(N2)).containsExactly(N1); 230 assertThat(network.predecessors(N1)).containsExactly(N2); 231 } 232 233 @Test successors_oneEdge()234 public void successors_oneEdge() { 235 addEdge(N1, N2, E12); 236 assertThat(network.successors(N1)).containsExactly(N2); 237 assertThat(network.successors(N2)).containsExactly(N1); 238 } 239 240 @Test inDegree_oneEdge()241 public void inDegree_oneEdge() { 242 addEdge(N1, N2, E12); 243 assertThat(network.inDegree(N2)).isEqualTo(1); 244 assertThat(network.inDegree(N1)).isEqualTo(1); 245 } 246 247 @Test outDegree_oneEdge()248 public void outDegree_oneEdge() { 249 addEdge(N1, N2, E12); 250 assertThat(network.outDegree(N1)).isEqualTo(1); 251 assertThat(network.outDegree(N2)).isEqualTo(1); 252 } 253 254 @Test edges_selfLoop()255 public void edges_selfLoop() { 256 assume().that(network.allowsSelfLoops()).isTrue(); 257 258 addEdge(N1, N1, E11); 259 assertThat(network.edges()).containsExactly(E11); 260 } 261 262 @Test incidentEdges_selfLoop()263 public void incidentEdges_selfLoop() { 264 assume().that(network.allowsSelfLoops()).isTrue(); 265 266 addEdge(N1, N1, E11); 267 assertThat(network.incidentEdges(N1)).containsExactly(E11); 268 } 269 270 @Test incidentNodes_selfLoop()271 public void incidentNodes_selfLoop() { 272 assume().that(network.allowsSelfLoops()).isTrue(); 273 274 addEdge(N1, N1, E11); 275 assertThat(network.incidentNodes(E11).nodeU()).isEqualTo(N1); 276 assertThat(network.incidentNodes(E11).nodeV()).isEqualTo(N1); 277 } 278 279 @Test adjacentNodes_selfLoop()280 public void adjacentNodes_selfLoop() { 281 assume().that(network.allowsSelfLoops()).isTrue(); 282 283 addEdge(N1, N1, E11); 284 addEdge(N1, N2, E12); 285 assertThat(network.adjacentNodes(N1)).containsExactly(N1, N2); 286 } 287 288 @Test adjacentEdges_selfLoop()289 public void adjacentEdges_selfLoop() { 290 assume().that(network.allowsSelfLoops()).isTrue(); 291 292 addEdge(N1, N1, E11); 293 addEdge(N1, N2, E12); 294 assertThat(network.adjacentEdges(E11)).containsExactly(E12); 295 } 296 297 @Test edgesConnecting_selfLoop()298 public void edgesConnecting_selfLoop() { 299 assume().that(network.allowsSelfLoops()).isTrue(); 300 301 addEdge(N1, N1, E11); 302 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); 303 addEdge(N1, N2, E12); 304 assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12); 305 assertThat(network.edgesConnecting(N2, N1)).containsExactly(E12); 306 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); 307 } 308 309 @Test inEdges_selfLoop()310 public void inEdges_selfLoop() { 311 assume().that(network.allowsSelfLoops()).isTrue(); 312 313 addEdge(N1, N1, E11); 314 assertThat(network.inEdges(N1)).containsExactly(E11); 315 addEdge(N1, N2, E12); 316 assertThat(network.inEdges(N1)).containsExactly(E11, E12); 317 } 318 319 @Test outEdges_selfLoop()320 public void outEdges_selfLoop() { 321 assume().that(network.allowsSelfLoops()).isTrue(); 322 323 addEdge(N1, N1, E11); 324 assertThat(network.outEdges(N1)).containsExactly(E11); 325 addEdge(N2, N1, E12); 326 assertThat(network.outEdges(N1)).containsExactly(E11, E12); 327 } 328 329 @Test predecessors_selfLoop()330 public void predecessors_selfLoop() { 331 assume().that(network.allowsSelfLoops()).isTrue(); 332 333 addEdge(N1, N1, E11); 334 assertThat(network.predecessors(N1)).containsExactly(N1); 335 addEdge(N1, N2, E12); 336 assertThat(network.predecessors(N1)).containsExactly(N1, N2); 337 } 338 339 @Test successors_selfLoop()340 public void successors_selfLoop() { 341 assume().that(network.allowsSelfLoops()).isTrue(); 342 343 addEdge(N1, N1, E11); 344 assertThat(network.successors(N1)).containsExactly(N1); 345 addEdge(N2, N1, E12); 346 assertThat(network.successors(N1)).containsExactly(N1, N2); 347 } 348 349 @Test degree_selfLoop()350 public void degree_selfLoop() { 351 assume().that(network.allowsSelfLoops()).isTrue(); 352 353 addEdge(N1, N1, E11); 354 assertThat(network.degree(N1)).isEqualTo(2); 355 addEdge(N1, N2, E12); 356 assertThat(network.degree(N1)).isEqualTo(3); 357 } 358 359 @Test inDegree_selfLoop()360 public void inDegree_selfLoop() { 361 assume().that(network.allowsSelfLoops()).isTrue(); 362 363 addEdge(N1, N1, E11); 364 assertThat(network.inDegree(N1)).isEqualTo(2); 365 addEdge(N1, N2, E12); 366 assertThat(network.inDegree(N1)).isEqualTo(3); 367 } 368 369 @Test outDegree_selfLoop()370 public void outDegree_selfLoop() { 371 assume().that(network.allowsSelfLoops()).isTrue(); 372 373 addEdge(N1, N1, E11); 374 assertThat(network.outDegree(N1)).isEqualTo(2); 375 addEdge(N2, N1, E12); 376 assertThat(network.outDegree(N1)).isEqualTo(3); 377 } 378 379 // Element Mutation 380 381 @Test addEdge_existingNodes()382 public void addEdge_existingNodes() { 383 assume().that(graphIsMutable()).isTrue(); 384 385 // Adding nodes initially for safety (insulating from possible future 386 // modifications to proxy methods) 387 addNode(N1); 388 addNode(N2); 389 assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12)).isTrue(); 390 assertThat(network.edges()).contains(E12); 391 assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12); 392 assertThat(network.edgesConnecting(N2, N1)).containsExactly(E12); 393 } 394 395 @Test addEdge_existingEdgeBetweenSameNodes()396 public void addEdge_existingEdgeBetweenSameNodes() { 397 assume().that(graphIsMutable()).isTrue(); 398 399 assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12)).isTrue(); 400 ImmutableSet<String> edges = ImmutableSet.copyOf(network.edges()); 401 assertThat(networkAsMutableNetwork.addEdge(N1, N2, E12)).isFalse(); 402 assertThat(network.edges()).containsExactlyElementsIn(edges); 403 assertThat(networkAsMutableNetwork.addEdge(N2, N1, E12)).isFalse(); 404 assertThat(network.edges()).containsExactlyElementsIn(edges); 405 } 406 407 @Test addEdge_existingEdgeBetweenDifferentNodes()408 public void addEdge_existingEdgeBetweenDifferentNodes() { 409 assume().that(graphIsMutable()).isTrue(); 410 411 addEdge(N1, N2, E12); 412 IllegalArgumentException e = 413 assertThrows( 414 IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(N4, N5, E12)); 415 assertThat(e).hasMessageThat().contains(ERROR_REUSE_EDGE); 416 } 417 418 @Test addEdge_parallelEdge_notAllowed()419 public void addEdge_parallelEdge_notAllowed() { 420 assume().that(graphIsMutable()).isTrue(); 421 assume().that(network.allowsParallelEdges()).isFalse(); 422 423 addEdge(N1, N2, E12); 424 IllegalArgumentException e = 425 assertThrows( 426 IllegalArgumentException.class, 427 () -> networkAsMutableNetwork.addEdge(N1, N2, EDGE_NOT_IN_GRAPH)); 428 assertThat(e).hasMessageThat().contains(ERROR_PARALLEL_EDGE); 429 e = 430 assertThrows( 431 IllegalArgumentException.class, 432 () -> networkAsMutableNetwork.addEdge(N2, N1, EDGE_NOT_IN_GRAPH)); 433 assertThat(e).hasMessageThat().contains(ERROR_PARALLEL_EDGE); 434 } 435 436 @Test addEdge_parallelEdge_allowsParallelEdges()437 public void addEdge_parallelEdge_allowsParallelEdges() { 438 assume().that(graphIsMutable()).isTrue(); 439 assume().that(network.allowsParallelEdges()).isTrue(); 440 441 assertTrue(networkAsMutableNetwork.addEdge(N1, N2, E12)); 442 assertTrue(networkAsMutableNetwork.addEdge(N2, N1, E21)); 443 assertTrue(networkAsMutableNetwork.addEdge(N1, N2, E12_A)); 444 assertThat(network.edgesConnecting(N1, N2)).containsExactly(E12, E12_A, E21); 445 } 446 447 @Test addEdge_orderMismatch()448 public void addEdge_orderMismatch() { 449 assume().that(graphIsMutable()).isTrue(); 450 451 EndpointPair<Integer> endpoints = EndpointPair.ordered(N1, N2); 452 IllegalArgumentException e = 453 assertThrows( 454 IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(endpoints, E12)); 455 assertThat(e).hasMessageThat().contains(ENDPOINTS_MISMATCH); 456 } 457 458 @Test addEdge_selfLoop_notAllowed()459 public void addEdge_selfLoop_notAllowed() { 460 assume().that(graphIsMutable()).isTrue(); 461 assume().that(network.allowsSelfLoops()).isFalse(); 462 463 IllegalArgumentException e = 464 assertThrows( 465 IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(N1, N1, E11)); 466 assertThat(e).hasMessageThat().contains(ERROR_SELF_LOOP); 467 } 468 469 /** 470 * This test checks an implementation dependent feature. It tests that the method {@code addEdge} 471 * will silently add the missing nodes to the graph, then add the edge connecting them. We are not 472 * using the proxy methods here as we want to test {@code addEdge} when the end-points are not 473 * elements of the graph. 474 */ 475 @Test addEdge_nodesNotInGraph()476 public void addEdge_nodesNotInGraph() { 477 assume().that(graphIsMutable()).isTrue(); 478 479 networkAsMutableNetwork.addNode(N1); 480 assertTrue(networkAsMutableNetwork.addEdge(N1, N5, E15)); 481 assertTrue(networkAsMutableNetwork.addEdge(N4, N1, E41)); 482 assertTrue(networkAsMutableNetwork.addEdge(N2, N3, E23)); 483 assertThat(network.nodes()).containsExactly(N1, N5, N4, N2, N3); 484 assertThat(network.edges()).containsExactly(E15, E41, E23); 485 assertThat(network.edgesConnecting(N1, N5)).containsExactly(E15); 486 assertThat(network.edgesConnecting(N4, N1)).containsExactly(E41); 487 assertThat(network.edgesConnecting(N2, N3)).containsExactly(E23); 488 assertThat(network.edgesConnecting(N3, N2)).containsExactly(E23); 489 } 490 491 @Test addEdge_selfLoop()492 public void addEdge_selfLoop() { 493 assume().that(graphIsMutable()).isTrue(); 494 assume().that(network.allowsSelfLoops()).isTrue(); 495 496 assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11)).isTrue(); 497 assertThat(network.edges()).contains(E11); 498 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11); 499 } 500 501 @Test addEdge_existingSelfLoopEdgeBetweenSameNodes()502 public void addEdge_existingSelfLoopEdgeBetweenSameNodes() { 503 assume().that(graphIsMutable()).isTrue(); 504 assume().that(network.allowsSelfLoops()).isTrue(); 505 506 addEdge(N1, N1, E11); 507 ImmutableSet<String> edges = ImmutableSet.copyOf(network.edges()); 508 assertThat(networkAsMutableNetwork.addEdge(N1, N1, E11)).isFalse(); 509 assertThat(network.edges()).containsExactlyElementsIn(edges); 510 } 511 512 @Test addEdge_existingEdgeBetweenDifferentNodes_selfLoops()513 public void addEdge_existingEdgeBetweenDifferentNodes_selfLoops() { 514 assume().that(graphIsMutable()).isTrue(); 515 assume().that(network.allowsSelfLoops()).isTrue(); 516 517 addEdge(N1, N1, E11); 518 IllegalArgumentException e = 519 assertThrows( 520 IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(N1, N2, E11)); 521 assertThat(e).hasMessageThat().contains(ERROR_REUSE_EDGE); 522 e = 523 assertThrows( 524 IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(N2, N2, E11)); 525 assertThat(e).hasMessageThat().contains(ERROR_REUSE_EDGE); 526 addEdge(N1, N2, E12); 527 e = 528 assertThrows( 529 IllegalArgumentException.class, () -> networkAsMutableNetwork.addEdge(N1, N1, E12)); 530 assertThat(e).hasMessageThat().contains(ERROR_REUSE_EDGE); 531 } 532 533 @Test addEdge_parallelSelfLoopEdge_notAllowed()534 public void addEdge_parallelSelfLoopEdge_notAllowed() { 535 assume().that(graphIsMutable()).isTrue(); 536 assume().that(network.allowsSelfLoops()).isTrue(); 537 assume().that(network.allowsParallelEdges()).isFalse(); 538 539 addEdge(N1, N1, E11); 540 IllegalArgumentException e = 541 assertThrows( 542 IllegalArgumentException.class, 543 () -> networkAsMutableNetwork.addEdge(N1, N1, EDGE_NOT_IN_GRAPH)); 544 assertThat(e).hasMessageThat().contains(ERROR_PARALLEL_EDGE); 545 } 546 547 @Test addEdge_parallelSelfLoopEdge_allowsParallelEdges()548 public void addEdge_parallelSelfLoopEdge_allowsParallelEdges() { 549 assume().that(graphIsMutable()).isTrue(); 550 assume().that(network.allowsSelfLoops()).isTrue(); 551 assume().that(network.allowsParallelEdges()).isTrue(); 552 553 assertTrue(networkAsMutableNetwork.addEdge(N1, N1, E11)); 554 assertTrue(networkAsMutableNetwork.addEdge(N1, N1, E11_A)); 555 assertThat(network.edgesConnecting(N1, N1)).containsExactly(E11, E11_A); 556 } 557 558 @Test removeNode_existingNodeWithSelfLoopEdge()559 public void removeNode_existingNodeWithSelfLoopEdge() { 560 assume().that(graphIsMutable()).isTrue(); 561 assume().that(network.allowsSelfLoops()).isTrue(); 562 563 addNode(N1); 564 addEdge(N1, N1, E11); 565 assertThat(networkAsMutableNetwork.removeNode(N1)).isTrue(); 566 assertThat(network.nodes()).isEmpty(); 567 assertThat(network.edges()).doesNotContain(E11); 568 } 569 570 @Test removeEdge_existingSelfLoopEdge()571 public void removeEdge_existingSelfLoopEdge() { 572 assume().that(graphIsMutable()).isTrue(); 573 assume().that(network.allowsSelfLoops()).isTrue(); 574 575 addEdge(N1, N1, E11); 576 assertThat(networkAsMutableNetwork.removeEdge(E11)).isTrue(); 577 assertThat(network.edges()).doesNotContain(E11); 578 assertThat(network.edgesConnecting(N1, N1)).isEmpty(); 579 } 580 } 581