warrence/grapherity
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix clippy findings and related issues

Browse Source
This commit is contained in:
warrence
2026-10-13 21:25:50 +02:00
parent 7cfee9cce5
commit 3d1e8246a8
11 changed files with 179 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/dfs.rs
+7 -13
View File
@@ -162,11 +162,10 @@ where
G::Vertex: Debug,
{
let (graph, vertices, _, _) = G::standard();
for i in 0..10 {
for v in vertices {
assert!(
algorithms::dfs_find(&graph, vertices[0], vertices[i]),
"vertex {:?} should be reachable from {:?}",
vertices[i],
algorithms::dfs_find(&graph, vertices[0], v),
"vertex {v:?} should be reachable from {:?}",
vertices[0]
);
}
@@ -328,12 +327,8 @@ fn assert_dfs_visited<G: GraphTopology>(
) where
G::Vertex: Debug,
{
for i in 0..10 {
assert!(
visited[vertices[i]],
"vertex {:?} should be visited",
vertices[i]
);
for &v in vertices {
assert!(visited[v], "vertex {v:?} should be visited");
}
}
@@ -349,9 +344,8 @@ fn assert_dfs_predecessors<G: GraphTopology>(
predecessors[vertices[0]], None,
"source should have no predecessor"
);
for i in 1..10 {
let v = vertices[i];
let p = predecessors[v].expect(&format!("vertex {v:?} should have a predecessor"));
for &v in vertices.iter().skip(1) {
let p = predecessors[v].unwrap_or_else(|| panic!("vertex {v:?} should have a predecessor"));
assert!(
visited[p],
"predecessor {p:?} of vertex {v:?} should be visited"
tests/dijkstra.rs
+25 -32
View File
@@ -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)
}