From 600664acb6fb8c5f97bc48f2dc328bb0ad192ed7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Stefan=20M=C3=BCller?= Date: Wed, 13 May 2026 14:02:07 +0200 Subject: [PATCH] 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 + src/testing/dijkstra_testing.rs | 152 +++++++++++++++++++++++ src/testing/graph_topology_testing.rs | 3 - tests/dijkstra.rs | 166 ++------------------------ 4 files changed, 163 insertions(+), 159 deletions(-) create mode 100644 src/testing/dijkstra_testing.rs diff --git a/src/testing.rs b/src/testing.rs index 6dccf6c..0d4f69d 100644 --- a/src/testing.rs +++ b/src/testing.rs @@ -1,2 +1,3 @@ +pub(crate) mod dijkstra_testing; pub(crate) mod graph_topology_testing; pub(crate) mod maps_testing; diff --git a/src/testing/dijkstra_testing.rs b/src/testing/dijkstra_testing.rs new file mode 100644 index 0000000..25b939f --- /dev/null +++ b/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] + ); + } + } + }; +} diff --git a/src/testing/graph_topology_testing.rs b/src/testing/graph_topology_testing.rs index f8bae96..21bd040 100644 --- a/src/testing/graph_topology_testing.rs +++ b/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) => { diff --git a/tests/dijkstra.rs b/tests/dijkstra.rs index 6b45023..1e4db9f 100644 --- a/tests/dijkstra.rs +++ b/tests/dijkstra.rs @@ -1,161 +1,15 @@ -use grapherity::algorithms; -use grapherity::models::append_graph::AppendGraph; -use grapherity::traits::GraphTopology; +mod append_graph_tests { + use grapherity::models::append_graph::AppendGraph; + use grapherity::traits::GraphTopology; -#[test] -fn dijkstra_single_vertex() { - 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", - ); + grapherity::graph_topology_test_fixtures!(AppendGraph); + grapherity::dijkstra_tests!(AppendGraph); } -#[test] -fn dijkstra_disconnected() { - let mut graph = AppendGraph::new(); - 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", - ); -} +mod graph_tests { + use grapherity::models::graph::Graph; + use grapherity::traits::GraphTopology; -#[test] -fn dijkstra() { - 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, [::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) + grapherity::graph_topology_test_fixtures!(Graph); + grapherity::dijkstra_tests!(Graph); }