233 lines
8.2 KiB
Rust
233 lines
8.2 KiB
Rust
/*!
|
|
This module defines tests and test helpers for substring implementations.
|
|
*/
|
|
|
|
use alloc::{
|
|
boxed::Box,
|
|
format,
|
|
string::{String, ToString},
|
|
};
|
|
|
|
pub(crate) mod naive;
|
|
#[macro_use]
|
|
pub(crate) mod prop;
|
|
|
|
const SEEDS: &'static [Seed] = &[
|
|
Seed::new("", "", Some(0), Some(0)),
|
|
Seed::new("", "a", Some(0), Some(1)),
|
|
Seed::new("", "ab", Some(0), Some(2)),
|
|
Seed::new("", "abc", Some(0), Some(3)),
|
|
Seed::new("a", "", None, None),
|
|
Seed::new("a", "a", Some(0), Some(0)),
|
|
Seed::new("a", "aa", Some(0), Some(1)),
|
|
Seed::new("a", "ba", Some(1), Some(1)),
|
|
Seed::new("a", "bba", Some(2), Some(2)),
|
|
Seed::new("a", "bbba", Some(3), Some(3)),
|
|
Seed::new("a", "bbbab", Some(3), Some(3)),
|
|
Seed::new("a", "bbbabb", Some(3), Some(3)),
|
|
Seed::new("a", "bbbabbb", Some(3), Some(3)),
|
|
Seed::new("a", "bbbbbb", None, None),
|
|
Seed::new("ab", "", None, None),
|
|
Seed::new("ab", "a", None, None),
|
|
Seed::new("ab", "b", None, None),
|
|
Seed::new("ab", "ab", Some(0), Some(0)),
|
|
Seed::new("ab", "aab", Some(1), Some(1)),
|
|
Seed::new("ab", "aaab", Some(2), Some(2)),
|
|
Seed::new("ab", "abaab", Some(0), Some(3)),
|
|
Seed::new("ab", "baaab", Some(3), Some(3)),
|
|
Seed::new("ab", "acb", None, None),
|
|
Seed::new("ab", "abba", Some(0), Some(0)),
|
|
Seed::new("abc", "ab", None, None),
|
|
Seed::new("abc", "abc", Some(0), Some(0)),
|
|
Seed::new("abc", "abcz", Some(0), Some(0)),
|
|
Seed::new("abc", "abczz", Some(0), Some(0)),
|
|
Seed::new("abc", "zabc", Some(1), Some(1)),
|
|
Seed::new("abc", "zzabc", Some(2), Some(2)),
|
|
Seed::new("abc", "azbc", None, None),
|
|
Seed::new("abc", "abzc", None, None),
|
|
Seed::new("abczdef", "abczdefzzzzzzzzzzzzzzzzzzzz", Some(0), Some(0)),
|
|
Seed::new("abczdef", "zzzzzzzzzzzzzzzzzzzzabczdef", Some(20), Some(20)),
|
|
Seed::new(
|
|
"xyz",
|
|
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxyz",
|
|
Some(32),
|
|
Some(32),
|
|
),
|
|
Seed::new("\u{0}\u{15}", "\u{0}\u{15}\u{15}\u{0}", Some(0), Some(0)),
|
|
Seed::new("\u{0}\u{1e}", "\u{1e}\u{0}", None, None),
|
|
];
|
|
|
|
/// Runs a host of substring search tests.
|
|
///
|
|
/// This has support for "partial" substring search implementations only work
|
|
/// for a subset of needles/haystacks. For example, the "packed pair" substring
|
|
/// search implementation only works for haystacks of some minimum length based
|
|
/// of the pair of bytes selected and the size of the vector used.
|
|
pub(crate) struct Runner {
|
|
fwd: Option<
|
|
Box<dyn FnMut(&[u8], &[u8]) -> Option<Option<usize>> + 'static>,
|
|
>,
|
|
rev: Option<
|
|
Box<dyn FnMut(&[u8], &[u8]) -> Option<Option<usize>> + 'static>,
|
|
>,
|
|
}
|
|
|
|
impl Runner {
|
|
/// Create a new test runner for forward and reverse substring search
|
|
/// implementations.
|
|
pub(crate) fn new() -> Runner {
|
|
Runner { fwd: None, rev: None }
|
|
}
|
|
|
|
/// Run all tests. This panics on the first failure.
|
|
///
|
|
/// If the implementation being tested returns `None` for a particular
|
|
/// haystack/needle combination, then that test is skipped.
|
|
///
|
|
/// This runs tests on both the forward and reverse implementations given.
|
|
/// If either (or both) are missing, then tests for that implementation are
|
|
/// skipped.
|
|
pub(crate) fn run(self) {
|
|
if let Some(mut fwd) = self.fwd {
|
|
for seed in SEEDS.iter() {
|
|
for t in seed.generate() {
|
|
match fwd(t.haystack.as_bytes(), t.needle.as_bytes()) {
|
|
None => continue,
|
|
Some(result) => {
|
|
assert_eq!(
|
|
t.fwd, result,
|
|
"FORWARD, needle: {:?}, haystack: {:?}",
|
|
t.needle, t.haystack,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if let Some(mut rev) = self.rev {
|
|
for seed in SEEDS.iter() {
|
|
for t in seed.generate() {
|
|
match rev(t.haystack.as_bytes(), t.needle.as_bytes()) {
|
|
None => continue,
|
|
Some(result) => {
|
|
assert_eq!(
|
|
t.rev, result,
|
|
"REVERSE, needle: {:?}, haystack: {:?}",
|
|
t.needle, t.haystack,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Set the implementation for forward substring search.
|
|
///
|
|
/// If the closure returns `None`, then it is assumed that the given
|
|
/// test cannot be applied to the particular implementation and it is
|
|
/// skipped. For example, if a particular implementation only supports
|
|
/// needles or haystacks for some minimum length.
|
|
///
|
|
/// If this is not set, then forward substring search is not tested.
|
|
pub(crate) fn fwd(
|
|
mut self,
|
|
search: impl FnMut(&[u8], &[u8]) -> Option<Option<usize>> + 'static,
|
|
) -> Runner {
|
|
self.fwd = Some(Box::new(search));
|
|
self
|
|
}
|
|
|
|
/// Set the implementation for reverse substring search.
|
|
///
|
|
/// If the closure returns `None`, then it is assumed that the given
|
|
/// test cannot be applied to the particular implementation and it is
|
|
/// skipped. For example, if a particular implementation only supports
|
|
/// needles or haystacks for some minimum length.
|
|
///
|
|
/// If this is not set, then reverse substring search is not tested.
|
|
pub(crate) fn rev(
|
|
mut self,
|
|
search: impl FnMut(&[u8], &[u8]) -> Option<Option<usize>> + 'static,
|
|
) -> Runner {
|
|
self.rev = Some(Box::new(search));
|
|
self
|
|
}
|
|
}
|
|
|
|
/// A single substring test for forward and reverse searches.
|
|
#[derive(Clone, Debug)]
|
|
struct Test {
|
|
needle: String,
|
|
haystack: String,
|
|
fwd: Option<usize>,
|
|
rev: Option<usize>,
|
|
}
|
|
|
|
/// A single substring test for forward and reverse searches.
|
|
///
|
|
/// Each seed is valid on its own, but it also serves as a starting point
|
|
/// to generate more tests. Namely, we pad out the haystacks with other
|
|
/// characters so that we get more complete coverage. This is especially useful
|
|
/// for testing vector algorithms that tend to have weird special cases for
|
|
/// alignment and loop unrolling.
|
|
///
|
|
/// Padding works by assuming certain characters never otherwise appear in a
|
|
/// needle or a haystack. Neither should contain a `#` character.
|
|
#[derive(Clone, Copy, Debug)]
|
|
struct Seed {
|
|
needle: &'static str,
|
|
haystack: &'static str,
|
|
fwd: Option<usize>,
|
|
rev: Option<usize>,
|
|
}
|
|
|
|
impl Seed {
|
|
const MAX_PAD: usize = 34;
|
|
|
|
const fn new(
|
|
needle: &'static str,
|
|
haystack: &'static str,
|
|
fwd: Option<usize>,
|
|
rev: Option<usize>,
|
|
) -> Seed {
|
|
Seed { needle, haystack, fwd, rev }
|
|
}
|
|
|
|
fn generate(self) -> impl Iterator<Item = Test> {
|
|
assert!(!self.needle.contains('#'), "needle must not contain '#'");
|
|
assert!(!self.haystack.contains('#'), "haystack must not contain '#'");
|
|
(0..=Seed::MAX_PAD)
|
|
// Generate tests for padding at the beginning of haystack.
|
|
.map(move |pad| {
|
|
let needle = self.needle.to_string();
|
|
let prefix = "#".repeat(pad);
|
|
let haystack = format!("{}{}", prefix, self.haystack);
|
|
let fwd = if needle.is_empty() {
|
|
Some(0)
|
|
} else {
|
|
self.fwd.map(|i| pad + i)
|
|
};
|
|
let rev = if needle.is_empty() {
|
|
Some(haystack.len())
|
|
} else {
|
|
self.rev.map(|i| pad + i)
|
|
};
|
|
Test { needle, haystack, fwd, rev }
|
|
})
|
|
// Generate tests for padding at the end of haystack.
|
|
.chain((1..=Seed::MAX_PAD).map(move |pad| {
|
|
let needle = self.needle.to_string();
|
|
let suffix = "#".repeat(pad);
|
|
let haystack = format!("{}{}", self.haystack, suffix);
|
|
let fwd = if needle.is_empty() { Some(0) } else { self.fwd };
|
|
let rev = if needle.is_empty() {
|
|
Some(haystack.len())
|
|
} else {
|
|
self.rev
|
|
};
|
|
Test { needle, haystack, fwd, rev }
|
|
}))
|
|
}
|
|
}
|