259 lines
8.8 KiB
Rust
259 lines
8.8 KiB
Rust
#[doc(hidden)]
|
|
#[macro_export]
|
|
macro_rules! bfs_tests {
|
|
($T:ty) => {
|
|
#[test]
|
|
fn bfs_single_vertex() {
|
|
use $crate::traits::GraphTopology;
|
|
let mut graph = <$T>::new();
|
|
let v = graph.add_vertex();
|
|
let result = $crate::algorithms::bfs(&graph, v);
|
|
assert_eq!(
|
|
result.distances[v],
|
|
Some(0),
|
|
"unexpected distance of source vertex"
|
|
);
|
|
assert_eq!(
|
|
result.predecessors[v], None,
|
|
"unexpected predecessor of source vertex"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_disconnected() {
|
|
let (graph, vertices) = make_test_graph_disconnected();
|
|
let result = $crate::algorithms::bfs(&graph, vertices[0]);
|
|
assert_eq!(
|
|
result.distances[vertices[0]],
|
|
Some(0),
|
|
"unexpected distance of source vertex"
|
|
);
|
|
assert_eq!(
|
|
result.predecessors[vertices[0]], None,
|
|
"unexpected predecessor of source vertex"
|
|
);
|
|
for &v in &vertices[1..3] {
|
|
assert_eq!(
|
|
result.distances[v], None,
|
|
"disconnected vertex {v:?} should have no distance"
|
|
);
|
|
assert_eq!(
|
|
result.predecessors[v], None,
|
|
"disconnected vertex {v:?} should have no predecessor"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn bfs() {
|
|
let (graph, vertices, _, _) = make_test_graph();
|
|
let result = $crate::algorithms::bfs(&graph, vertices[0]);
|
|
assert_bfs_distances(&result.distances, &vertices);
|
|
assert_bfs_predecessors(&result.predecessors, &vertices);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_distances_single_vertex() {
|
|
use $crate::traits::GraphTopology;
|
|
let mut graph = <$T>::new();
|
|
let v = graph.add_vertex();
|
|
let distances = $crate::algorithms::bfs_distances(&graph, v);
|
|
assert_eq!(
|
|
distances[v],
|
|
Some(0),
|
|
"unexpected distance of source vertex"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_distances_disconnected() {
|
|
let (graph, vertices) = make_test_graph_disconnected();
|
|
let distances = $crate::algorithms::bfs_distances(&graph, vertices[0]);
|
|
assert_eq!(
|
|
distances[vertices[0]],
|
|
Some(0),
|
|
"unexpected distance of source vertex"
|
|
);
|
|
for &v in &vertices[1..3] {
|
|
assert_eq!(
|
|
distances[v], None,
|
|
"disconnected vertex {v:?} should have no distance"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_distances() {
|
|
let (graph, vertices, _, _) = make_test_graph();
|
|
let distances = $crate::algorithms::bfs_distances(&graph, vertices[0]);
|
|
assert_bfs_distances(&distances, &vertices);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find_source() {
|
|
use $crate::traits::GraphTopology;
|
|
let mut graph = <$T>::new();
|
|
let v = graph.add_vertex();
|
|
assert_eq!(
|
|
$crate::algorithms::bfs_find(&graph, v, v),
|
|
Some(0),
|
|
"source should be found at distance 0"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find_disconnected() {
|
|
let (graph, vertices) = make_test_graph_disconnected();
|
|
assert_eq!(
|
|
$crate::algorithms::bfs_find(&graph, vertices[0], vertices[1]),
|
|
None,
|
|
"disconnected target should not be found"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find() {
|
|
let (graph, vertices, _, _) = make_test_graph();
|
|
let expected_distances = [
|
|
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!(
|
|
$crate::algorithms::bfs_find(&graph, vertices[0], vertices[i]),
|
|
expected_distances[i],
|
|
"unexpected distance from {:?} to {:?}",
|
|
vertices[0],
|
|
vertices[i]
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find_where_source_matches() {
|
|
use $crate::traits::GraphTopology;
|
|
let mut graph = <$T>::new();
|
|
let v = graph.add_vertex();
|
|
assert_eq!(
|
|
$crate::algorithms::bfs_find_where(&graph, v, |u| u == v),
|
|
Some((v, 0)),
|
|
"source should match with distance 0"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find_where_disconnected() {
|
|
let (graph, vertices) = make_test_graph_disconnected();
|
|
assert_eq!(
|
|
$crate::algorithms::bfs_find_where(&graph, vertices[0], |v| v == vertices[1]),
|
|
None,
|
|
"disconnected vertex {:?} should not be found",
|
|
vertices[1]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find_where_no_match() {
|
|
let (graph, vertices, _, _) = make_test_graph();
|
|
assert_eq!(
|
|
$crate::algorithms::bfs_find_where(&graph, vertices[0], |_| false),
|
|
None,
|
|
"no vertex should match an always-false predicate"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn bfs_find_where_nearest() {
|
|
let (graph, vertices, _, _) = make_test_graph();
|
|
// vertices[5], vertices[6], vertices[7], vertices[8] are all at distance 3 from vertices[0].
|
|
// vertices[9] is at distance 4. Predicate matches vertices[7], vertices[8], vertices[9].
|
|
// BFS must return one of the distance-3 ones, not vertices[9].
|
|
let result = $crate::algorithms::bfs_find_where(&graph, vertices[0], |v| {
|
|
v == vertices[7] || v == vertices[8] || v == vertices[9]
|
|
});
|
|
assert!(result.is_some(), "expected a match");
|
|
let (found, distance) = result.unwrap();
|
|
assert_eq!(
|
|
distance, 3,
|
|
"unexpected distance to nearest matching vertex {found:?}",
|
|
);
|
|
assert!(
|
|
found == vertices[7] || found == vertices[8],
|
|
"unexpected nearest match vertex {found:?}, should be {:?} or {:?}",
|
|
vertices[7],
|
|
vertices[8]
|
|
);
|
|
}
|
|
|
|
fn assert_bfs_distances(
|
|
distances: &$crate::maps::VertexMap<
|
|
<$T as $crate::traits::GraphTopology>::Vertex,
|
|
Option<u32>,
|
|
>,
|
|
vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
|
|
) {
|
|
let expected = [
|
|
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[i],
|
|
"unexpected BFS distance from {:?} to {:?}",
|
|
vertices[0], vertices[i]
|
|
);
|
|
}
|
|
}
|
|
|
|
fn assert_bfs_predecessors(
|
|
predecessors: &$crate::maps::VertexMap<
|
|
<$T as $crate::traits::GraphTopology>::Vertex,
|
|
Option<<$T as $crate::traits::GraphTopology>::Vertex>,
|
|
>,
|
|
vertices: &[<$T as $crate::traits::GraphTopology>::Vertex],
|
|
) {
|
|
assert_eq!(
|
|
predecessors[vertices[0]], None,
|
|
"source should have no predecessor"
|
|
);
|
|
// Each non-source vertex's predecessor must be adjacent and at distance one less.
|
|
let expected_predecessors = [
|
|
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 1..10 {
|
|
assert!(
|
|
expected_predecessors[i].contains(&predecessors[vertices[i]]),
|
|
"unexpected predecessor {:?} of {:?}",
|
|
predecessors[vertices[i]],
|
|
vertices[i]
|
|
);
|
|
}
|
|
}
|
|
};
|
|
}
|