Move common test helpers to fixtures module

tests/dijkstra.rs

@@ -4,6 +4,7 @@ use std::hash::Hash;
 use grapherity::algorithms;
 use grapherity::algorithms::DijkstraResult;
 use grapherity::maps::ElementMap;
+use grapherity::testing::fixtures;
 use grapherity::testing::fixtures::MakeTestGraph;
 use grapherity::traits::{GraphTopology, Incidence};
 
@@ -94,18 +95,19 @@ fn dijkstra<G: MakeTestGraph>()
 where
     G::Vertex: Debug + Hash,
 {
-    let (graph, vertices, _, _, weights) = make_test_graph_weighted::<G>();
+    let (graph, vertices, _, _, weights) = make_standard_weighted::<G>();
     let result = algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
-    assert_test_graph::<G>(&result, &vertices);
+    assert_standard_weighted_distances_v0::<G>(&result.distances, &vertices);
+    assert_standard_weighted_predecessors_v0::<G>(&result.predecessors, &vertices);
 }
 
 fn dijkstra_distances<G: MakeTestGraph>()
 where
     G::Vertex: Debug + Hash,
 {
-    let (graph, vertices, _, _, weights) = make_test_graph_weighted::<G>();
+    let (graph, vertices, _, _, weights) = make_standard_weighted::<G>();
     let distances = algorithms::dijkstra_distances(&graph, vertices[0], |e| weights[e]);
-    assert_distances_test_graph::<G>(&distances, &vertices);
+    assert_standard_weighted_distances_v0::<G>(&distances, &vertices);
 }
 
 fn dijkstra_unweighted_single_vertex<G: MakeTestGraph>()
@@ -133,7 +135,8 @@ where
 {
     let (graph, vertices, _, _) = G::standard();
     let result = algorithms::dijkstra_unweighted(&graph, vertices[0]);
-    assert_unweighted_test_graph::<G>(&result, &vertices);
+    fixtures::assert_standard_unweighted_distances_v0(|v| result.distances[v], &vertices);
+    fixtures::assert_standard_unweighted_predecessors_v0(&result.predecessors, &vertices);
 }
 
 fn dijkstra_distances_unweighted_single_vertex<G: MakeTestGraph>()
@@ -161,7 +164,7 @@ where
 {
     let (graph, vertices, _, _) = G::standard();
     let distances = algorithms::dijkstra_distances_unweighted(&graph, vertices[0]);
-    assert_distances_unweighted_test_graph::<G>(&distances, &vertices);
+    fixtures::assert_standard_unweighted_distances_v0(|v| distances[v], &vertices);
 }
 
 fn assert_single_vertex<G: GraphTopology>(result: &DijkstraResult<G::Vertex>, v: G::Vertex)
@@ -213,12 +216,13 @@ fn assert_distances_disconnected<G: GraphTopology>(
     }
 }
 
-fn assert_test_graph<G: GraphTopology>(result: &DijkstraResult<G::Vertex>, vertices: &[G::Vertex])
-where
+fn assert_standard_weighted_predecessors_v0<G: GraphTopology>(
+    actual: &ElementMap<G::Vertex, Option<G::Vertex>>,
+    vertices: &[G::Vertex],
+) where
     G::Vertex: Debug,
 {
-    assert_distances_test_graph::<G>(&result.distances, &vertices);
-    let expected_predecessors_from_v0 = [
+    let expected = [
         vec![None],
         vec![Some(vertices[0])],
         vec![Some(vertices[4])],
@@ -232,21 +236,21 @@ where
     ];
     for i in 0..10 {
         assert!(
-            expected_predecessors_from_v0[i].contains(&result.predecessors[vertices[i]]),
+            expected[i].contains(&actual[vertices[i]]),
             "unexpected predecessor {:?} of {:?}",
-            result.predecessors[vertices[i]],
+            actual[vertices[i]],
             vertices[i]
         );
     }
 }
 
-fn assert_distances_test_graph<G: GraphTopology>(
-    distances: &ElementMap<G::Vertex, Option<u32>>,
+fn assert_standard_weighted_distances_v0<G: GraphTopology>(
+    actual: &ElementMap<G::Vertex, Option<u32>>,
     vertices: &[G::Vertex],
 ) where
     G::Vertex: Debug,
 {
-    let expected_distances_from_v0 = [
+    let expected = [
         Some(0),
         Some(1),
         Some(65),
@@ -260,70 +264,14 @@ fn assert_distances_test_graph<G: GraphTopology>(
     ];
     for i in 0..10 {
         assert_eq!(
-            distances[vertices[i]], expected_distances_from_v0[i],
+            actual[vertices[i]], expected[i],
             "unexpected distance from {:?} to {:?}",
             vertices[0], vertices[i]
         );
     }
 }
 
-fn assert_unweighted_test_graph<G: GraphTopology>(
-    result: &DijkstraResult<G::Vertex>,
-    vertices: &[G::Vertex],
-) where
-    G::Vertex: Debug,
-{
-    assert_distances_unweighted_test_graph::<G>(&result.distances, &vertices);
-    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..10 {
-        assert!(
-            expected_predecessors_from_v0[i].contains(&result.predecessors[vertices[i]]),
-            "unexpected predecessor {:?} of {:?}",
-            result.predecessors[vertices[i]],
-            vertices[i]
-        );
-    }
-}
-
-fn assert_distances_unweighted_test_graph<G: GraphTopology>(
-    distances: &ElementMap<G::Vertex, Option<u32>>,
-    vertices: &[G::Vertex],
-) where
-    G::Vertex: Debug,
-{
-    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..10 {
-        assert_eq!(
-            distances[vertices[i]], expected_distances_from_v0[i],
-            "unexpected distance from {:?} to {:?}",
-            vertices[0], vertices[i]
-        );
-    }
-}
-
-fn make_test_graph_weighted<G: MakeTestGraph>() -> (
+fn make_standard_weighted<G: MakeTestGraph>() -> (
     G,
     [G::Vertex; 10],
     [(G::Edge, G::Vertex, G::Vertex); 18],