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) => {