Add GraphTopology::incident_vertices and tests

src/testing/graph_topology_testing.rs

@@ -365,6 +365,84 @@ macro_rules! graph_topology_tests {
             }
         }
 
+        #[test]
+        fn incident_vertices_single_edge() {
+            let mut graph = <$T>::new();
+            let v1 = graph.add_vertex();
+            let v2 = graph.add_vertex();
+            let e = graph.add_edge(v1, v2);
+            let (u1, u2) = graph.incident_vertices(e);
+            assert!(
+                (u1 == v1 && u2 == v2) || (u1 == v2 && u2 == v1),
+                "unexpected incident vertices {u1:?} and {u2:?} for edge {e:?}"
+            );
+        }
+
+        #[test]
+        fn incident_vertices_loop_edge() {
+            let mut graph = <$T>::new();
+            let v = graph.add_vertex();
+            let e = graph.add_edge(v, v);
+            assert_eq!(
+                graph.incident_vertices(e),
+                (v, v),
+                "unexpected incident vertices for loop edge {e:?}"
+            );
+        }
+
+        #[test]
+        fn incident_vertices_multiple_edges() {
+            let mut graph = <$T>::new();
+            let v1 = graph.add_vertex();
+            let v2 = graph.add_vertex();
+            let e1 = graph.add_edge(v1, v2);
+            let e2 = graph.add_edge(v1, v2);
+            assert_ne!(e1, e2, "edges should be distinct");
+            let (u1, u2) = graph.incident_vertices(e1);
+            assert!(
+                (u1 == v1 && u2 == v2) || (u1 == v2 && u2 == v1),
+                "unexpected incident vertices {u1:?} and {u2:?} for first multi-edge {e1:?}"
+            );
+            let (u1, u2) = graph.incident_vertices(e2);
+            assert!(
+                (u1 == v1 && u2 == v2) || (u1 == v2 && u2 == v1),
+                "unexpected incident vertices {u1:?} and {u2:?} for second multi-edge {e2:?}"
+            );
+        }
+
+        #[test]
+        fn incident_vertices() {
+            let (graph, vertices, edges, _) = make_test_graph();
+            let expected: [(<$T as $crate::traits::GraphTopology>::Vertex, <$T as $crate::traits::GraphTopology>::Vertex); 18] = [
+                (vertices[0], vertices[1]),
+                (vertices[0], vertices[1]),
+                (vertices[1], vertices[2]),
+                (vertices[1], vertices[3]),
+                (vertices[1], vertices[4]),
+                (vertices[2], vertices[2]),
+                (vertices[2], vertices[4]),
+                (vertices[2], vertices[4]),
+                (vertices[2], vertices[5]),
+                (vertices[2], vertices[6]),
+                (vertices[3], vertices[6]),
+                (vertices[4], vertices[4]),
+                (vertices[4], vertices[7]),
+                (vertices[4], vertices[8]),
+                (vertices[5], vertices[9]),
+                (vertices[6], vertices[9]),
+                (vertices[7], vertices[8]),
+                (vertices[7], vertices[9]),
+            ];
+            for (i, &(v1, v2)) in expected.iter().enumerate() {
+                let (u1, u2) = graph.incident_vertices(edges[i]);
+                assert!(
+                    (u1 == v1 && u2 == v2) || (u1 == v2 && u2 == v1),
+                    "unexpected incident vertices {u1:?} and {u2:?} for edges[{i}]: edge {:?}",
+                    edges[i]
+                );
+            }
+        }
+
         #[test]
         fn edges_empty() {
             let graph = <$T>::new();
@@ -514,6 +592,20 @@ macro_rules! graph_topology_tests {
                     vertices[i]
                 );
             }
+        }
+
+               #[test]
+        fn incident_vertices_incidences_consistency() {
+            let (graph, _, _, _) = make_test_graph();
+            for u in graph.vertices() {
+                for (v, e) in graph.incidences(u) {
+                    let (w1, w2) = graph.incident_vertices(e);
+                    assert!(
+                        (w1 == u && w2 == v) || (w1 == v && w2 == u),
+                        "incident vertices {w1:?} and {w2:?} of edge {e:?} are inconsistent with incidence ({v:?}, {e:?}) of vertex {u:?}"
+                    );
+                }
+            }
         }
     };
 }
@@ -800,6 +892,43 @@ macro_rules! graph_topology_deletion_tests {
             }
         }
 
+        #[test]
+        fn incident_vertices_after_delete_edge() {
+            let (mut graph, vertices, edges, _) = make_test_graph();
+            graph.delete_edge(edges[2]);
+            let expected: [(
+                usize,
+                <Graph as $crate::traits::GraphTopology>::Vertex,
+                <Graph as $crate::traits::GraphTopology>::Vertex,
+            ); 17] = [
+                (0, vertices[0], vertices[1]),
+                (1, vertices[0], vertices[1]),
+                (3, vertices[1], vertices[3]),
+                (4, vertices[1], vertices[4]),
+                (5, vertices[2], vertices[2]),
+                (6, vertices[2], vertices[4]),
+                (7, vertices[2], vertices[4]),
+                (8, vertices[2], vertices[5]),
+                (9, vertices[2], vertices[6]),
+                (10, vertices[3], vertices[6]),
+                (11, vertices[4], vertices[4]),
+                (12, vertices[4], vertices[7]),
+                (13, vertices[4], vertices[8]),
+                (14, vertices[5], vertices[9]),
+                (15, vertices[6], vertices[9]),
+                (16, vertices[7], vertices[8]),
+                (17, vertices[7], vertices[9]),
+            ];
+            for (i, v1, v2) in expected {
+                let (u1, u2) = graph.incident_vertices(edges[i]);
+                assert!(
+                    (u1 == v1 && u2 == v2) || (u1 == v2 && u2 == v1),
+                    "unexpected incident vertices {u1:?} and {u2:?} for edges[{i}] ({:?}) after delete",
+                    edges[i]
+                );
+            }
+        }
+
         #[test]
         fn edges_after_delete() {
             let (mut graph, vertices, edges, _) = make_test_graph();