Refactor graph trait tests to minimize macro code, and split into separate files per macro
The tests only declare a list of tests in the macro, no longer the test functions themselves. This allows better tooling support (e.g. IDE and rustfmt).
This commit is contained in:
@@ -0,0 +1,542 @@
|
||||
use std::fmt::Debug;
|
||||
|
||||
use crate::testing::fixtures::MakeTestGraph;
|
||||
use crate::traits::{
|
||||
GraphTopology, GraphTopologyAddition, GraphTopologyDeletion, Incidence, IncidenceCursor,
|
||||
};
|
||||
|
||||
#[doc(hidden)]
|
||||
#[macro_export]
|
||||
macro_rules! graph_topology_deletion_tests {
|
||||
($T:ty) => {
|
||||
$crate::graph_topology_deletion_tests!(@wrap $T,
|
||||
delete_vertex,
|
||||
delete_vertex_loop,
|
||||
delete_vertex_invalid_index,
|
||||
delete_vertex_connected,
|
||||
delete_edge,
|
||||
delete_edge_loop,
|
||||
delete_edge_multiple,
|
||||
delete_edge_invalid_index,
|
||||
vertices_after_delete,
|
||||
incident_vertices_after_delete_edge,
|
||||
edges_after_delete,
|
||||
incident_edges_after_delete_edge,
|
||||
incident_edges_after_delete_vertex,
|
||||
incidences_after_delete_vertex,
|
||||
incidences_after_delete_edge,
|
||||
incidence_cursor_after_delete_vertex,
|
||||
incidence_cursor_after_delete_edge,
|
||||
);
|
||||
};
|
||||
|
||||
(@wrap $T:ty, $($name:ident),* $(,)?) => {
|
||||
$(
|
||||
#[test]
|
||||
fn $name() {
|
||||
$crate::testing::graph_topology_deletion_testing::$name::<$T>();
|
||||
}
|
||||
)*
|
||||
};
|
||||
}
|
||||
|
||||
pub(crate) fn delete_vertex<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
let (mut graph, v) = G::single_vertex();
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
1,
|
||||
"unexpected vertex count before delete"
|
||||
);
|
||||
graph.delete_vertex(v);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
0,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
}
|
||||
|
||||
pub(crate) fn delete_vertex_loop<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
let (mut graph, v, _) = G::loop_edge();
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
1,
|
||||
"unexpected vertex count before delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 1, "unexpected edge count before delete");
|
||||
assert!(
|
||||
graph.are_adjacent(v, v),
|
||||
"expected vertex to be self-adjacent before delete"
|
||||
);
|
||||
assert_eq!(graph.degree(v), 2, "unexpected vertex degree before delete");
|
||||
graph.delete_vertex(v);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
0,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 0, "unexpected edge count after delete");
|
||||
}
|
||||
|
||||
pub(crate) fn delete_vertex_invalid_index<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
let (mut graph, v) = G::single_vertex();
|
||||
graph.delete_vertex(v);
|
||||
let result =
|
||||
std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || graph.delete_vertex(v)));
|
||||
assert!(result.is_err(), "second deletion should panic");
|
||||
}
|
||||
|
||||
pub(crate) fn delete_vertex_connected<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
{
|
||||
let (mut graph, vertices, _, _) = G::standard();
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
10,
|
||||
"unexpected vertex count before delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.edge_count(),
|
||||
18,
|
||||
"unexpected edge count before delete"
|
||||
);
|
||||
graph.delete_vertex(vertices[2]);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
9,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 12, "unexpected edge count after delete");
|
||||
let expected_edges = [
|
||||
(vertices[0], vertices[1]),
|
||||
(vertices[1], vertices[3]),
|
||||
(vertices[1], vertices[4]),
|
||||
(vertices[3], vertices[6]),
|
||||
(vertices[4], vertices[4]),
|
||||
(vertices[4], vertices[7]),
|
||||
(vertices[4], vertices[8]),
|
||||
(vertices[5], vertices[9]),
|
||||
(vertices[6], vertices[9]),
|
||||
(vertices[7], vertices[8]),
|
||||
(vertices[7], vertices[9]),
|
||||
];
|
||||
for (v, u) in expected_edges {
|
||||
assert!(
|
||||
graph.are_adjacent(v, u),
|
||||
"expected {v:?} and {u:?} to be adjacent after delete"
|
||||
);
|
||||
}
|
||||
for v in [vertices[1], vertices[4], vertices[5], vertices[6]] {
|
||||
assert!(
|
||||
!graph.adjacent_vertices(v).any(|u| u == vertices[2]),
|
||||
"unexpected adjacency of {v:?} to deleted vertex {:?}",
|
||||
vertices[2]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn delete_edge<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
let (mut graph, vertices, e) = G::single_edge();
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
2,
|
||||
"unexpected vertex count before delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 1, "unexpected edge count before delete");
|
||||
assert!(
|
||||
graph.are_adjacent(vertices[0], vertices[1]),
|
||||
"expected vertices to be adjacent before delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[0]),
|
||||
1,
|
||||
"unexpected vertex degree before delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[1]),
|
||||
1,
|
||||
"unexpected vertex degree before delete"
|
||||
);
|
||||
graph.delete_edge(e);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
2,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 0, "unexpected edge count after delete");
|
||||
assert!(
|
||||
!graph.are_adjacent(vertices[0], vertices[1]),
|
||||
"unexpected adjacency after delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[0]),
|
||||
0,
|
||||
"unexpected vertex degree after delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[1]),
|
||||
0,
|
||||
"unexpected vertex degree after delete"
|
||||
);
|
||||
}
|
||||
|
||||
pub(crate) fn delete_edge_loop<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
let (mut graph, v, e) = G::loop_edge();
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
1,
|
||||
"unexpected vertex count before delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 1, "unexpected edge count before delete");
|
||||
assert!(
|
||||
graph.are_adjacent(v, v),
|
||||
"expected vertex to be self-adjacent before delete"
|
||||
);
|
||||
assert_eq!(graph.degree(v), 2, "unexpected vertex degree before delete");
|
||||
graph.delete_edge(e);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
1,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), 0, "unexpected edge count after delete");
|
||||
assert!(
|
||||
!graph.are_adjacent(v, v),
|
||||
"unexpected adjacency after delete"
|
||||
);
|
||||
assert_eq!(graph.degree(v), 0, "unexpected vertex degree after delete");
|
||||
}
|
||||
|
||||
pub(crate) fn delete_edge_multiple<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
const K: usize = 2;
|
||||
let (mut graph, vertices, edges) = G::multiple_edges::<K>();
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
2,
|
||||
"unexpected vertex count before delete"
|
||||
);
|
||||
assert_eq!(graph.edge_count(), K, "unexpected edge count before delete");
|
||||
assert!(
|
||||
graph.are_adjacent(vertices[0], vertices[1]),
|
||||
"expected vertices to be adjacent before delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[0]),
|
||||
K,
|
||||
"unexpected vertex degree before delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[1]),
|
||||
K,
|
||||
"unexpected vertex degree before delete"
|
||||
);
|
||||
graph.delete_edge(edges[0]);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
2,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.edge_count(),
|
||||
K - 1,
|
||||
"unexpected edge count after delete"
|
||||
);
|
||||
assert!(
|
||||
graph.are_adjacent(vertices[0], vertices[1]),
|
||||
"expected vertices to be adjacent after delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[0]),
|
||||
K - 1,
|
||||
"unexpected vertex degree after delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.degree(vertices[1]),
|
||||
K - 1,
|
||||
"unexpected vertex degree after delete"
|
||||
);
|
||||
}
|
||||
|
||||
pub(crate) fn delete_edge_invalid_index<G: GraphTopologyDeletion + GraphTopologyAddition>() {
|
||||
let (mut graph, _, e) = G::single_edge();
|
||||
graph.delete_edge(e);
|
||||
let result =
|
||||
std::panic::catch_unwind(std::panic::AssertUnwindSafe(move || graph.delete_edge(e)));
|
||||
assert!(result.is_err(), "second deletion should panic");
|
||||
}
|
||||
|
||||
pub(crate) fn vertices_after_delete<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
{
|
||||
let (mut graph, vertices, _, _) = G::standard();
|
||||
graph.delete_vertex(vertices[2]);
|
||||
assert_eq!(
|
||||
graph.vertex_count(),
|
||||
9,
|
||||
"unexpected vertex count after delete"
|
||||
);
|
||||
assert_eq!(
|
||||
graph.vertices().count(),
|
||||
9,
|
||||
"unexpected vertex iterator count after delete"
|
||||
);
|
||||
for v in graph.vertices() {
|
||||
assert_ne!(
|
||||
v, vertices[2],
|
||||
"deleted vertex {:?} appeared in iterator",
|
||||
vertices[2]
|
||||
);
|
||||
}
|
||||
for i in [0, 1, 3, 4, 5, 6, 7, 8, 9] {
|
||||
assert!(
|
||||
graph.vertices().any(|v| v == vertices[i]),
|
||||
"expected vertex {:?} missing from iterator after delete",
|
||||
vertices[i]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incident_vertices_after_delete_edge<
|
||||
G: GraphTopologyDeletion + GraphTopologyAddition,
|
||||
>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, _, edges, _) = G::standard();
|
||||
let e = edges[2].0;
|
||||
graph.delete_edge(e);
|
||||
for &(f, v1, v2) in edges.iter().filter(|&&(f, _, _)| f != e) {
|
||||
let (u1, u2) = graph.incident_vertices(f);
|
||||
assert!(
|
||||
(u1 == v1 && u2 == v2) || (u1 == v2 && u2 == v1),
|
||||
"unexpected incident vertices {u1:?} and {u2:?} for edge {f:?} after delete"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn edges_after_delete<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, edges, _) = G::standard();
|
||||
graph.delete_vertex(vertices[2]);
|
||||
assert_eq!(graph.edge_count(), 12, "unexpected edge count after delete");
|
||||
assert_eq!(
|
||||
graph.edges().count(),
|
||||
12,
|
||||
"unexpected edge iterator count after delete"
|
||||
);
|
||||
for i in [2, 5, 6, 7, 8, 9] {
|
||||
assert!(
|
||||
!graph.edges().any(|e| e == edges[i].0),
|
||||
"deleted edge {:?} appeared in iterator",
|
||||
edges[i].0
|
||||
);
|
||||
}
|
||||
for i in [0, 1, 3, 4, 10, 11, 12, 13, 14, 15, 16, 17] {
|
||||
assert!(
|
||||
graph.edges().any(|e| e == edges[i].0),
|
||||
"expected edge {:?} missing from iterator after delete",
|
||||
edges[i].0
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incident_edges_after_delete_edge<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, edges, incidences) = G::standard();
|
||||
graph.delete_edge(edges[2].0);
|
||||
for i in 0..10 {
|
||||
let mut expected: Vec<_> = incidences[i]
|
||||
.iter()
|
||||
.filter_map(|x| (x.edge != edges[2].0).then_some(x.edge))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
graph.incident_edges(vertices[i]).count(),
|
||||
expected.len(),
|
||||
"unexpected incident edge count for vertex {:?} after delete",
|
||||
vertices[i]
|
||||
);
|
||||
for e in graph.incident_edges(vertices[i]) {
|
||||
let pos = expected.iter().position(|f| *f == e).expect(&format!(
|
||||
"unexpected incident edge {e:?} of vertex {:?} after delete",
|
||||
vertices[i]
|
||||
));
|
||||
expected.swap_remove(pos);
|
||||
}
|
||||
assert!(
|
||||
expected.is_empty(),
|
||||
"expected incident edges {:?} of vertex {:?} not matched after delete",
|
||||
expected,
|
||||
vertices[i]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incident_edges_after_delete_vertex<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, _, incidences) = G::standard();
|
||||
graph.delete_vertex(vertices[2]);
|
||||
for i in [0, 1, 3, 4, 5, 6, 7, 8, 9] {
|
||||
let mut expected: Vec<_> = incidences[i]
|
||||
.iter()
|
||||
.filter_map(|x| (x.vertex != vertices[2]).then_some(x.edge))
|
||||
.collect();
|
||||
assert_eq!(
|
||||
graph.incident_edges(vertices[i]).count(),
|
||||
expected.len(),
|
||||
"unexpected incident edge count for vertex {:?} after delete",
|
||||
vertices[i]
|
||||
);
|
||||
for e in graph.incident_edges(vertices[i]) {
|
||||
let pos = expected.iter().position(|f| *f == e).expect(&format!(
|
||||
"unexpected incident edge {e:?} of vertex {:?} after delete",
|
||||
vertices[i]
|
||||
));
|
||||
expected.swap_remove(pos);
|
||||
}
|
||||
assert!(
|
||||
expected.is_empty(),
|
||||
"expected incident edges {:?} of vertex {:?} not matched after delete",
|
||||
expected,
|
||||
vertices[i]
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incidences_after_delete_vertex<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, _, incidences) = G::standard();
|
||||
graph.delete_vertex(vertices[2]);
|
||||
for i in [0, 1, 3, 4, 5, 6, 7, 8, 9] {
|
||||
let remaining = incidences[i]
|
||||
.iter()
|
||||
.filter(|x| x.vertex != vertices[2])
|
||||
.cloned()
|
||||
.collect();
|
||||
assert_vertex_incidences(&graph, vertices[i], remaining);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incidences_after_delete_edge<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, edges, incidences) = G::standard();
|
||||
graph.delete_edge(edges[2].0);
|
||||
for i in 0..10 {
|
||||
let remaining = incidences[i]
|
||||
.iter()
|
||||
.filter(|x| x.edge != edges[2].0)
|
||||
.cloned()
|
||||
.collect();
|
||||
assert_vertex_incidences(&graph, vertices[i], remaining);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incidence_cursor_after_delete_vertex<
|
||||
G: GraphTopologyDeletion + GraphTopologyAddition,
|
||||
>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, _, incidences) = G::standard();
|
||||
graph.delete_vertex(vertices[2]);
|
||||
for i in [0, 1, 3, 4, 5, 6, 7, 8, 9] {
|
||||
let remaining = incidences[i]
|
||||
.iter()
|
||||
.filter(|x| x.vertex != vertices[2])
|
||||
.cloned()
|
||||
.collect();
|
||||
assert_vertex_incidence_cursor(&graph, vertices[i], remaining);
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn incidence_cursor_after_delete_edge<G: GraphTopologyDeletion + GraphTopologyAddition>()
|
||||
where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let (mut graph, vertices, edges, incidences) = G::standard();
|
||||
graph.delete_edge(edges[2].0);
|
||||
for i in 0..10 {
|
||||
let remaining = incidences[i]
|
||||
.iter()
|
||||
.filter(|x| x.edge != edges[2].0)
|
||||
.cloned()
|
||||
.collect();
|
||||
assert_vertex_incidence_cursor(&graph, vertices[i], remaining);
|
||||
}
|
||||
}
|
||||
|
||||
fn assert_vertex_incidences<G: GraphTopology>(
|
||||
graph: &G,
|
||||
v: G::Vertex,
|
||||
mut expected: Vec<Incidence<G::Vertex, G::Edge>>,
|
||||
) where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
assert_eq!(
|
||||
graph.incidences(v).count(),
|
||||
expected.len(),
|
||||
"unexpected incidence count for vertex {:?} after delete",
|
||||
v
|
||||
);
|
||||
for incidence in graph.incidences(v) {
|
||||
let pos = expected
|
||||
.iter()
|
||||
.position(|x| *x == incidence)
|
||||
.expect(&format!(
|
||||
"unexpected incidence {incidence:?} of vertex {:?} from iterator after delete",
|
||||
v
|
||||
));
|
||||
expected.swap_remove(pos);
|
||||
}
|
||||
assert!(
|
||||
expected.is_empty(),
|
||||
"expected incidences {:?} of vertex {:?} not matched by iterator after delete",
|
||||
expected,
|
||||
v
|
||||
);
|
||||
}
|
||||
|
||||
fn assert_vertex_incidence_cursor<G: GraphTopology>(
|
||||
graph: &G,
|
||||
v: G::Vertex,
|
||||
mut expected: Vec<Incidence<G::Vertex, G::Edge>>,
|
||||
) where
|
||||
G::Vertex: Debug,
|
||||
G::Edge: Debug,
|
||||
{
|
||||
let mut cursor = graph.incidence_cursor(v);
|
||||
while let Some(incidence) = cursor.next(graph) {
|
||||
let pos = expected
|
||||
.iter()
|
||||
.position(|x| *x == incidence)
|
||||
.expect(&format!(
|
||||
"unexpected incidence {incidence:?} of vertex {:?} from cursor after delete",
|
||||
v
|
||||
));
|
||||
expected.swap_remove(pos);
|
||||
}
|
||||
assert!(
|
||||
expected.is_empty(),
|
||||
"expected incidences {:?} of vertex {:?} not matched by cursor after delete",
|
||||
expected,
|
||||
v
|
||||
);
|
||||
}
|
||||
Reference in New Issue
Block a user