Add tests for Dijkstra's algorithm with edge weights

src/testing/dijkstra_testing.rs

@@ -1,6 +1,71 @@
 #[macro_export]
 macro_rules! dijkstra_tests {
     ($T:ty) => {
+        #[test]
+        fn dijkstra_single_vertex() {
+            let mut graph = <$T>::new();
+            let v = graph.add_vertex();
+            let result = $crate::algorithms::dijkstra(&graph, v, |_| {
+                panic!("unexpected call of weight functor")
+            });
+            assert_single_vertex(&result, v);
+        }
+
+        #[test]
+        fn dijkstra_disconnected() {
+            let (graph, vertices) = make_test_graph_dijkstra_disconnected();
+            let result = $crate::algorithms::dijkstra(&graph, vertices[0], |_| {
+                panic!("unexpected call of weight functor")
+            });
+            assert_single_vertex(&result, vertices[0]);
+            assert_disconnected(&result, &vertices[1..3]);
+        }
+
+        #[test]
+        fn dijkstra_zero_weight_loop() {
+            let mut graph = <$T>::new();
+            let vertices: [<$T as $crate::traits::GraphTopology>::Vertex; 3] =
+                core::array::from_fn(|_| graph.add_vertex());
+            let e1 = graph.add_edge(vertices[0], vertices[0]);
+            let e2 = graph.add_edge(vertices[1], vertices[1]);
+            graph.add_edge(vertices[0], vertices[1]);
+            graph.add_edge(vertices[1], vertices[2]);
+            let mut weights = graph.edge_map(1);
+            weights[e1] = 0;
+            weights[e2] = 0;
+            let result = $crate::algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
+            assert_single_vertex(&result, vertices[0]);
+            for i in 1..3 {
+                assert_eq!(
+                    result.predecessors[vertices[i]],
+                    Some(vertices[i - 1]),
+                    "unexpected predecessor of vertex {:?}",
+                    vertices[i]
+                );
+                assert_eq!(
+                    result.distances[vertices[i]],
+                    Some(i.try_into().unwrap()),
+                    "unexpected distance of vertex {:?}",
+                    vertices[i]
+                );
+            }
+        }
+
+        #[test]
+        fn dijkstra() {
+            let (graph, vertices, edges, _, weights) = make_test_graph_weighted();
+            let result = $crate::algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
+            assert_test_graph(&result, &vertices);
+        }
+
+        #[test]
+        fn dijkstra_distances() {
+            let (graph, vertices, edges, _, weights) = make_test_graph_weighted();
+            let distances =
+                $crate::algorithms::dijkstra_distances(&graph, vertices[0], |e| weights[e]);
+            assert_distances_test_graph(&distances, &vertices);
+        }
+
         #[test]
         fn dijkstra_unweighted_single_vertex() {
             let mut graph = <$T>::new();
@@ -226,5 +291,27 @@ macro_rules! dijkstra_tests {
             graph.add_edge(vertices[1], vertices[2]);
             (graph, vertices)
         }
+
+        fn make_test_graph_weighted() -> (
+            $T,
+            [<$T as $crate::traits::GraphTopology>::Vertex; 10],
+            [(
+                <$T as $crate::traits::GraphTopology>::Edge,
+                <$T as $crate::traits::GraphTopology>::Vertex,
+                <$T as $crate::traits::GraphTopology>::Vertex,
+            ); 18],
+            [Vec<(
+                <$T as $crate::traits::GraphTopology>::Vertex,
+                <$T as $crate::traits::GraphTopology>::Edge,
+            )>; 10],
+            $crate::maps::EdgeMap<<$T as $crate::traits::GraphTopology>::Edge, u32>,
+        ) {
+            let (graph, vertices, edges, incidences) = make_test_graph();
+            let mut weights = graph.edge_map(99_u32);
+            for i in [1, 3, 7, 10, 12, 14, 15, 17] {
+                weights[edges[i].0] = i.try_into().unwrap();
+            }
+            (graph, vertices, edges, incidences, weights)
+        }
     };
 }