Refactor Dijkstra test assertions into new functions

src/testing/dijkstra_testing.rs

@@ -4,64 +4,170 @@ macro_rules! dijkstra_tests {
         #[test]
         fn dijkstra_unweighted_single_vertex() {
             let mut graph = <$T>::new();
-            let v1 = graph.add_vertex();
+            let v = graph.add_vertex();
-            let result = $crate::algorithms::dijkstra_unweighted(&graph, v1);
+            let result = $crate::algorithms::dijkstra_unweighted(&graph, v);
-            assert_eq!(
+            assert_single_vertex(&result, v)
-                result.distances[v1],
-                Some(0),
-                "unexpected distance of source vertex"
-            );
-            assert_eq!(
-                result.predecessors[v1],
-                None,
-                "unexpected predecessor of source vertex",
-            );
         }
 
         #[test]
         fn dijkstra_unweighted_disconnected() {
-            let mut graph = <$T>::new();
+            let (graph, vertices) = make_test_graph_dijkstra_disconnected();
-            let v1 = graph.add_vertex();
+            let result = $crate::algorithms::dijkstra_unweighted(&graph, vertices[0]);
-            let v2 = graph.add_vertex();
+            assert_single_vertex(&result, vertices[0]);
-            let result = $crate::algorithms::dijkstra_unweighted(&graph, v1);
+            assert_disconnected(&result, &vertices[1..3]);
-            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_unweighted() {
             let (graph, vertices, _, _) = make_test_graph();
             let result = $crate::algorithms::dijkstra_unweighted(&graph, vertices[0]);
+            assert_unweighted_test_graph(&result, &vertices);
+        }
+
+        #[test]
+        fn dijkstra_distances_unweighted_single_vertex() {
+            let mut graph = <$T>::new();
+            let v = graph.add_vertex();
+            let distances = $crate::algorithms::dijkstra_distances_unweighted(&graph, v);
+            assert_distances_single_vertex(&distances, v);
+        }
+
+        #[test]
+        fn dijkstra_distances_unweighted_disconnected() {
+            let (graph, vertices) = make_test_graph_dijkstra_disconnected();
+            let distances = $crate::algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
+            assert_distances_single_vertex(&distances, vertices[0]);
+            assert_distances_disconnected(&distances, &vertices[1..3]);
+        }
+
+        #[test]
+        fn dijkstra_distances_unweighted() {
+            let (graph, vertices, _, _) = make_test_graph();
+            let distances = $crate::algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
+            assert_distances_unweighted_test_graph(&distances, &vertices);
+        }
+
+        fn assert_single_vertex(
+            result: &$crate::algorithms::DijkstraResult<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+            >,
+            v: <$T as $crate::traits::GraphTopology>::Vertex,
+        ) {
+            assert_distances_single_vertex(&result.distances, v);
+            assert_eq!(
+                result.predecessors[v], None,
+                "unexpected predecessor of source vertex",
+            );
+        }
+
+        fn assert_distances_single_vertex(
+            distances: &$crate::maps::VertexMap<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+                Option<u32>,
+            >,
+            v: <$T as $crate::traits::GraphTopology>::Vertex,
+        ) {
+            assert_eq!(
+                distances[v],
+                Some(0),
+                "unexpected distance of source vertex"
+            );
+        }
+
+        fn assert_disconnected(
+            result: &$crate::algorithms::DijkstraResult<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+            >,
+            vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
+        ) {
+            assert_distances_disconnected(&result.distances, &vertices);
+            for &v in vertices {
+                assert_eq!(
+                    result.predecessors[v], None,
+                    "unexpected predecessor of disconnected vertex {v:?}",
+                );
+            }
+        }
+
+        fn assert_distances_disconnected(
+            distances: &$crate::maps::VertexMap<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+                Option<u32>,
+            >,
+            vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
+        ) {
+            for &v in vertices {
+                assert_eq!(
+                    distances[v], None,
+                    "unexpected distance of disconnected vertex {v:?}",
+                );
+            }
+        }
+
+        fn assert_test_graph(
+            result: &$crate::algorithms::DijkstraResult<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+            >,
+            vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
+        ) {
+            assert_distances_test_graph(&result.distances, &vertices);
+            let expected_predecessors_from_v0 = [
+                vec![None],
+                vec![Some(vertices[0])],
+                vec![Some(vertices[4])],
+                vec![Some(vertices[1])],
+                vec![Some(vertices[7])],
+                vec![Some(vertices[9])],
+                vec![Some(vertices[3])],
+                vec![Some(vertices[9])],
+                vec![Some(vertices[7])],
+                vec![Some(vertices[6])],
+            ];
+            for i in 0..10 {
+                assert!(
+                    expected_predecessors_from_v0[i].contains(&result.predecessors[vertices[i]]),
+                    "unexpected predecessor {:?} of {:?}",
+                    result.predecessors[vertices[i]],
+                    vertices[i]
+                );
+            }
+        }
+
+        fn assert_distances_test_graph(
+            distances: &$crate::maps::VertexMap<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+                Option<u32>,
+            >,
+            vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
+        ) {
             let expected_distances_from_v0 = [
                 Some(0),
                 Some(1),
-                Some(2),
+                Some(65),
-                Some(2),
-                Some(2),
-                Some(3),
-                Some(3),
-                Some(3),
-                Some(3),
                 Some(4),
+                Some(58),
+                Some(43),
+                Some(14),
+                Some(46),
+                Some(145),
+                Some(29),
             ];
+            for i in 0..10 {
+                assert_eq!(
+                    distances[vertices[i]], expected_distances_from_v0[i],
+                    "unexpected distance from {:?} to {:?}",
+                    vertices[0], vertices[i]
+                );
+            }
+        }
+
+        fn assert_unweighted_test_graph(
+            result: &$crate::algorithms::DijkstraResult<
+                <$T as $crate::traits::GraphTopology>::Vertex,
+            >,
+            vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
+        ) {
+            assert_distances_unweighted_test_graph(&result.distances, &vertices);
             let expected_predecessors_from_v0 = [
                 vec![None],
                 vec![Some(vertices[0])],
@@ -74,14 +180,7 @@ macro_rules! dijkstra_tests {
                 vec![Some(vertices[4])],
                 vec![Some(vertices[5]), Some(vertices[6]), Some(vertices[7])],
             ];
-            for i in 0..graph.vertex_count() {
+            for i in 0..10 {
-                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 {:?}",
@@ -91,41 +190,13 @@ macro_rules! dijkstra_tests {
             }
         }
 
-        #[test]
+        fn assert_distances_unweighted_test_graph(
-        fn dijkstra_distances_unweighted_single_vertex() {
+            distances: &$crate::maps::VertexMap<
-            let mut graph = <$T>::new();
+                <$T as $crate::traits::GraphTopology>::Vertex,
-            let v1 = graph.add_vertex();
+                Option<u32>,
-            let distances = $crate::algorithms::dijkstra_distances_unweighted(&graph, v1);
+            >,
-            assert_eq!(
+            vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
-                distances[v1],
+        ) {
-                Some(0),
-                "unexpected distance of source vertex"
-            );
-        }
-
-        #[test]
-        fn dijkstra_distances_unweighted_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_unweighted() {
-            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),
@@ -138,15 +209,22 @@ macro_rules! dijkstra_tests {
                 Some(3),
                 Some(4),
             ];
-            for i in 0..graph.vertex_count() {
+            for i in 0..10 {
                 assert_eq!(
-                    distances[vertices[i]],
+                    distances[vertices[i]], expected_distances_from_v0[i],
-                    expected_distances_from_v0[i],
                     "unexpected distance from {:?} to {:?}",
-                    vertices[0],
+                    vertices[0], vertices[i]
-                    vertices[i]
                 );
             }
         }
+
+        fn make_test_graph_dijkstra_disconnected()
+        -> ($T, [<$T as $crate::traits::GraphTopology>::Vertex; 3]) {
+            let mut graph = <$T>::new();
+            let vertices: [<$T as $crate::traits::GraphTopology>::Vertex; 3] =
+                core::array::from_fn(|_| graph.add_vertex());
+            graph.add_edge(vertices[1], vertices[2]);
+            (graph, vertices)
+        }
     };
 }