Fix clippy findings and related issues

tests/dijkstra.rs

@@ -6,7 +6,7 @@ use grapherity::algorithms::DijkstraResult;
 use grapherity::maps::ElementMap;
 use grapherity::testing::fixtures;
 use grapherity::testing::fixtures::MakeTestGraph;
-use grapherity::traits::{GraphTopology, Incidence};
+use grapherity::traits::GraphTopology;
 
 macro_rules! dijkstra_tests {
     ($T:ty) => {
@@ -78,21 +78,19 @@ fn dijkstra_zero_weight_loop<G: MakeTestGraph>()
 where
     G::Vertex: Debug + Hash,
 {
-    let (graph, vertices, _, weights) = make_two_edge_path_with_zero_weight_loops::<G>();
+    let (graph, vertices, weights) = make_two_edge_path_with_zero_weight_loops::<G>();
     let result = algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
     assert_single_vertex::<G>(&result, vertices[0]);
-    for i in 1..3 {
+    for (i, &v) in vertices.iter().enumerate().skip(1) {
         assert_eq!(
-            result.predecessors[vertices[i]],
+            result.predecessors[v],
             Some(vertices[i - 1]),
-            "unexpected predecessor of vertex {:?}",
-            vertices[i]
+            "unexpected predecessor of vertex {v:?}"
         );
         assert_eq!(
-            result.distances[vertices[i]],
+            result.distances[v],
             Some(i.try_into().unwrap()),
-            "unexpected distance of vertex {:?}",
-            vertices[i]
+            "unexpected distance of vertex {v:?}"
         );
     }
 }
@@ -101,7 +99,7 @@ fn dijkstra<G: MakeTestGraph>()
 where
     G::Vertex: Debug + Hash,
 {
-    let (graph, vertices, _, _, weights) = make_standard_weighted::<G>();
+    let (graph, vertices, weights) = make_standard_weighted::<G>();
     let result = algorithms::dijkstra(&graph, vertices[0], |e| weights[e]);
     assert_standard_weighted_distances_v0::<G>(&result.distances, &vertices);
     assert_standard_weighted_predecessors_v0::<G>(&result.predecessors, &vertices);
@@ -111,7 +109,7 @@ fn dijkstra_distances<G: MakeTestGraph>()
 where
     G::Vertex: Debug + Hash,
 {
-    let (graph, vertices, _, _, weights) = make_standard_weighted::<G>();
+    let (graph, vertices, weights) = make_standard_weighted::<G>();
     let distances = algorithms::dijkstra_distances(&graph, vertices[0], |e| weights[e]);
     assert_standard_weighted_distances_v0::<G>(&distances, &vertices);
 }
@@ -201,7 +199,7 @@ fn assert_disconnected<G: GraphTopology>(
 ) where
     G::Vertex: Debug,
 {
-    assert_distances_disconnected::<G>(&result.distances, &vertices);
+    assert_distances_disconnected::<G>(&result.distances, vertices);
     for &v in vertices {
         assert_eq!(
             result.predecessors[v], None,
@@ -242,12 +240,12 @@ fn assert_standard_weighted_predecessors_v0<G: GraphTopology>(
         vec![Some(vertices[7])],
         vec![Some(vertices[6])],
     ];
-    for i in 0..10 {
+    assert_eq!(vertices.len(), expected.len());
+    for (&v, exp) in vertices.iter().zip(&expected) {
         assert!(
-            expected[i].contains(&actual[vertices[i]]),
-            "unexpected predecessor {:?} of {:?}",
-            actual[vertices[i]],
-            vertices[i]
+            exp.contains(&actual[v]),
+            "unexpected predecessor {:?} of {v:?}",
+            actual[v]
         );
     }
 }
@@ -270,35 +268,30 @@ fn assert_standard_weighted_distances_v0<G: GraphTopology>(
         Some(145),
         Some(29),
     ];
-    for i in 0..10 {
+    assert_eq!(vertices.len(), expected.len());
+    for (&v, &exp) in vertices.iter().zip(&expected) {
         assert_eq!(
-            actual[vertices[i]], expected[i],
-            "unexpected distance from {:?} to {:?}",
-            vertices[0], vertices[i]
+            actual[v], exp,
+            "unexpected distance from {:?} to {v:?}",
+            vertices[0]
         );
     }
 }
 
-fn make_standard_weighted<G: MakeTestGraph>() -> (
-    G,
-    [G::Vertex; 10],
-    [(G::Edge, G::Vertex, G::Vertex); 18],
-    [Vec<Incidence<G::Vertex, G::Edge>>; 10],
-    ElementMap<G::Edge, u32>,
-) {
-    let (graph, vertices, edges, incidences) = G::standard();
+fn make_standard_weighted<G: MakeTestGraph>() -> (G, [G::Vertex; 10], ElementMap<G::Edge, u32>) {
+    let (graph, vertices, edges, _) = G::standard();
     let mut weights = graph.edge_map(99);
     for i in [1, 3, 7, 10, 12, 14, 15, 17] {
         weights[edges[i].0] = i.try_into().unwrap();
     }
-    (graph, vertices, edges, incidences, weights)
+    (graph, vertices, weights)
 }
 
 fn make_two_edge_path_with_zero_weight_loops<G: MakeTestGraph>()
--> (G, [G::Vertex; 3], [G::Edge; 4], ElementMap<G::Edge, u32>) {
+-> (G, [G::Vertex; 3], ElementMap<G::Edge, u32>) {
     let (graph, vertices, edges) = G::two_edge_path_with_loops();
     let mut weights = graph.edge_map(1);
     weights[edges[2]] = 0;
     weights[edges[3]] = 0;
-    (graph, vertices, edges, weights)
+    (graph, vertices, weights)
 }