Update tests for Dijkstra's algorithm to test both graph models

Use the already established macro pattern, move actual tests to a new file in src/testing.
Use the make_test_graph() function from the graph topology tests instead of duplicating it for the Dijkstra tests.

src/testing.rs

@@ -1,2 +1,3 @@
+pub(crate) mod dijkstra_testing;
 pub(crate) mod graph_topology_testing;
 pub(crate) mod maps_testing;

src/testing/dijkstra_testing.rs

@@ -0,0 +1,152 @@
+#[macro_export]
+macro_rules! dijkstra_tests {
+    ($T:ty) => {
+        #[test]
+        fn dijkstra_single_vertex() {
+            let mut graph = <$T>::new();
+            let v1 = graph.add_vertex();
+            let result = $crate::algorithms::dijkstra_unweighted(&graph, v1);
+            assert_eq!(
+                result.distances[v1],
+                Some(0),
+                "unexpected distance of source vertex"
+            );
+            assert_eq!(
+                result.predecessors[v1],
+                None,
+                "unexpected predecessor of source vertex",
+            );
+        }
+
+        #[test]
+        fn dijkstra_disconnected() {
+            let mut graph = <$T>::new();
+            let v1 = graph.add_vertex();
+            let v2 = graph.add_vertex();
+            let result = $crate::algorithms::dijkstra_unweighted(&graph, v1);
+            assert_eq!(
+                result.distances[v1],
+                Some(0),
+                "unexpected distance of source vertex"
+            );
+            assert_eq!(
+                result.distances[v2],
+                None,
+                "unexpected distance of disconnected vertex"
+            );
+            assert_eq!(
+                result.predecessors[v1],
+                None,
+                "unexpected predecessor of source vertex",
+            );
+            assert_eq!(
+                result.predecessors[v2],
+                None,
+                "unexpected predecessor of disconnected vertex",
+            );
+        }
+
+        #[test]
+        fn dijkstra() {
+            let (graph, vertices, _, _) = make_test_graph();
+            let result = $crate::algorithms::dijkstra_unweighted(&graph, vertices[0]);
+            let expected_distances_from_v0 = [
+                Some(0),
+                Some(1),
+                Some(2),
+                Some(2),
+                Some(2),
+                Some(3),
+                Some(3),
+                Some(3),
+                Some(3),
+                Some(4),
+            ];
+            let expected_predecessors_from_v0 = [
+                vec![None],
+                vec![Some(vertices[0])],
+                vec![Some(vertices[1])],
+                vec![Some(vertices[1])],
+                vec![Some(vertices[1])],
+                vec![Some(vertices[2])],
+                vec![Some(vertices[2]), Some(vertices[3])],
+                vec![Some(vertices[4])],
+                vec![Some(vertices[4])],
+                vec![Some(vertices[5]), Some(vertices[6]), Some(vertices[7])],
+            ];
+            for i in 0..graph.vertex_count() {
+                assert_eq!(
+                    result.distances[vertices[i]],
+                    expected_distances_from_v0[i],
+                    "unexpected distance from {:?} to {:?}",
+                    vertices[0],
+                    vertices[i]
+                );
+                assert!(
+                    expected_predecessors_from_v0[i].contains(&result.predecessors[vertices[i]]),
+                    "unexpected predecessor {:?} of {:?}",
+                    result.predecessors[vertices[i]],
+                    vertices[i]
+                );
+            }
+        }
+
+        #[test]
+        fn dijkstra_distances_single_vertex() {
+            let mut graph = <$T>::new();
+            let v1 = graph.add_vertex();
+            let distances = $crate::algorithms::dijkstra_distances_unweighted(&graph, v1);
+            assert_eq!(
+                distances[v1],
+                Some(0),
+                "unexpected distance of source vertex"
+            );
+        }
+
+        #[test]
+        fn dijkstra_distances_disconnected() {
+            let mut graph = <$T>::new();
+            let v1 = graph.add_vertex();
+            let v2 = graph.add_vertex();
+            let distances = $crate::algorithms::dijkstra_distances_unweighted(&graph, v1);
+            assert_eq!(
+                distances[v1],
+                Some(0),
+                "unexpected distance of source vertex"
+            );
+            assert_eq!(
+                distances[v2],
+                None,
+                "unexpected distance of disconnected vertex",
+            );
+        }
+
+        #[test]
+        fn dijkstra_distances() {
+            let (graph, vertices, _, _) = make_test_graph();
+            let distances =
+                $crate::algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
+            let expected_distances_from_v0 = [
+                Some(0),
+                Some(1),
+                Some(2),
+                Some(2),
+                Some(2),
+                Some(3),
+                Some(3),
+                Some(3),
+                Some(3),
+                Some(4),
+            ];
+            for i in 0..graph.vertex_count() {
+                assert_eq!(
+                    distances[vertices[i]],
+                    expected_distances_from_v0[i],
+                    "unexpected distance from {:?} to {:?}",
+                    vertices[0],
+                    vertices[i]
+                );
+            }
+        }
+    };
+}

src/testing/graph_topology_testing.rs

@@ -1,4 +1,3 @@
-#[cfg(test)]
 #[macro_export]
 macro_rules! graph_topology_test_fixtures {
     ($T:ty) => {
@@ -90,7 +89,6 @@ macro_rules! graph_topology_test_fixtures {
     };
 }
 
-#[cfg(test)]
 #[macro_export]
 macro_rules! graph_topology_tests {
     ($T:ty) => {
@@ -702,7 +700,6 @@ macro_rules! graph_topology_tests {
     };
 }
 
-#[cfg(test)]
 #[macro_export]
 macro_rules! graph_topology_deletion_tests {
     ($T:ty) => {

tests/dijkstra.rs

@@ -1,161 +1,15 @@
-use grapherity::algorithms;
+mod append_graph_tests {
-use grapherity::models::append_graph::AppendGraph;
+    use grapherity::models::append_graph::AppendGraph;
-use grapherity::traits::GraphTopology;
+    use grapherity::traits::GraphTopology;
 
-#[test]
+    grapherity::graph_topology_test_fixtures!(AppendGraph);
-fn dijkstra_single_vertex() {
+    grapherity::dijkstra_tests!(AppendGraph);
-    let mut graph = AppendGraph::new();
-    let v1 = graph.add_vertex();
-    let result = algorithms::dijkstra_unweighted(&graph, v1);
-    assert_eq!(
-        result.distances[v1],
-        Some(0),
-        "unexpected distance of source vertex"
-    );
-    assert_eq!(
-        result.predecessors[v1], None,
-        "unexpected predecessor of source vertex",
-    );
 }
 
-#[test]
+mod graph_tests {
-fn dijkstra_disconnected() {
+    use grapherity::models::graph::Graph;
-    let mut graph = AppendGraph::new();
+    use grapherity::traits::GraphTopology;
-    let v1 = graph.add_vertex();
-    let v2 = graph.add_vertex();
-    let result = algorithms::dijkstra_unweighted(&graph, v1);
-    assert_eq!(
-        result.distances[v1],
-        Some(0),
-        "unexpected distance of source vertex"
-    );
-    assert_eq!(
-        result.distances[v2], None,
-        "unexpected distance of disconnected vertex"
-    );
-    assert_eq!(
-        result.predecessors[v1], None,
-        "unexpected predecessor of source vertex",
-    );
-    assert_eq!(
-        result.predecessors[v2], None,
-        "unexpected predecessor of disconnected vertex",
-    );
-}
 
-#[test]
+    grapherity::graph_topology_test_fixtures!(Graph);
-fn dijkstra() {
+    grapherity::dijkstra_tests!(Graph);
-    let (graph, vertices) = make_test_graph();
-    let result = algorithms::dijkstra_unweighted(&graph, vertices[0]);
-    let expected_distances_from_v0 = [
-        Some(0),
-        Some(1),
-        Some(2),
-        Some(2),
-        Some(2),
-        Some(3),
-        Some(3),
-        Some(3),
-        Some(3),
-        Some(4),
-    ];
-    let expected_predecessors_from_v0 = [
-        vec![None],
-        vec![Some(vertices[0])],
-        vec![Some(vertices[1])],
-        vec![Some(vertices[1])],
-        vec![Some(vertices[1])],
-        vec![Some(vertices[2])],
-        vec![Some(vertices[2]), Some(vertices[3])],
-        vec![Some(vertices[4])],
-        vec![Some(vertices[4])],
-        vec![Some(vertices[5]), Some(vertices[6]), Some(vertices[7])],
-    ];
-    for i in 0..graph.vertex_count() {
-        assert_eq!(
-            result.distances[vertices[i]], expected_distances_from_v0[i],
-            "unexpected distance from {:?} to {:?}",
-            vertices[0], vertices[i]
-        );
-        assert!(
-            expected_predecessors_from_v0[i].contains(&result.predecessors[vertices[i]]),
-            "unexpected predecessor {:?} of {:?}",
-            result.predecessors[vertices[i]],
-            vertices[i]
-        );
-    }
-}
-
-#[test]
-fn dijkstra_distances_single_vertex() {
-    let mut graph = AppendGraph::new();
-    let v1 = graph.add_vertex();
-    let distances = algorithms::dijkstra_distances_unweighted(&graph, v1);
-    assert_eq!(
-        distances[v1],
-        Some(0),
-        "unexpected distance of source vertex"
-    );
-}
-
-#[test]
-fn dijkstra_distances_disconnected() {
-    let mut graph = AppendGraph::new();
-    let v1 = graph.add_vertex();
-    let v2 = graph.add_vertex();
-    let distances = algorithms::dijkstra_distances_unweighted(&graph, v1);
-    assert_eq!(
-        distances[v1],
-        Some(0),
-        "unexpected distance of source vertex"
-    );
-    assert_eq!(
-        distances[v2], None,
-        "unexpected distance of disconnected vertex",
-    );
-}
-
-#[test]
-fn dijkstra_distances() {
-    let (graph, vertices) = make_test_graph();
-    let distances = algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
-    let expected_distances_from_v0 = [
-        Some(0),
-        Some(1),
-        Some(2),
-        Some(2),
-        Some(2),
-        Some(3),
-        Some(3),
-        Some(3),
-        Some(3),
-        Some(4),
-    ];
-    for i in 0..graph.vertex_count() {
-        assert_eq!(
-            distances[vertices[i]], expected_distances_from_v0[i],
-            "unexpected distance from {:?} to {:?}",
-            vertices[0], vertices[i]
-        );
-    }
-}
-
-fn make_test_graph() -> (AppendGraph, [<AppendGraph as GraphTopology>::Vertex; 10]) {
-    let mut graph = AppendGraph::new();
-    let vertices = core::array::from_fn::<_, 10, _>(|_| graph.add_vertex());
-    graph.add_edge(vertices[0], vertices[1]);
-    graph.add_edge(vertices[1], vertices[2]);
-    graph.add_edge(vertices[1], vertices[3]);
-    graph.add_edge(vertices[1], vertices[4]);
-    graph.add_edge(vertices[2], vertices[4]);
-    graph.add_edge(vertices[2], vertices[5]);
-    graph.add_edge(vertices[2], vertices[6]);
-    graph.add_edge(vertices[3], vertices[6]);
-    graph.add_edge(vertices[4], vertices[7]);
-    graph.add_edge(vertices[4], vertices[8]);
-    graph.add_edge(vertices[5], vertices[9]);
-    graph.add_edge(vertices[6], vertices[9]);
-    graph.add_edge(vertices[7], vertices[8]);
-    graph.add_edge(vertices[7], vertices[9]);
-    (graph, vertices)
 }