gnitz-expr 0.1.1

The expression evaluator of the gnitz database
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

use memchr::memmem::Finder;

use super::{fields, find, find_lit};

/// Every string of up to `max` bytes over `alphabet`.
fn words(alphabet: &[u8], max: u32) -> Vec<Vec<u8>> {
    (0..=max)
        .flat_map(|len| {
            (0..alphabet.len().pow(len)).map(move |code| {
                (0..len)
                    .map(|i| alphabet[code / alphabet.len().pow(i) % alphabet.len()])
                    .collect()
            })
        })
        .collect()
}

/// Both searches against the first window equal to the needle, over haystacks
/// both sides of the cutoff where the byte loop hands over to the vector scan.
#[test]
fn find_is_the_first_window_equal_to_the_needle() {
    let first_window = |h: &[u8], n: &[u8]| match n.is_empty() {
        true => Some(0),
        false => h.windows(n.len()).position(|w| w == n),
    };
    let short = words(b"ab", 10);
    let long: Vec<Vec<u8>> = words(b"ab", 5)
        .iter()
        .filter(|h| !h.is_empty())
        .flat_map(|h| {
            let base: Vec<u8> = h.iter().copied().cycle().take(37).collect();
            [[base.as_slice(), b"abbba"].concat(), base]
        })
        .collect();
    let needles: Vec<Vec<u8>> = words(b"ab", 3)
        .into_iter()
        .chain([b"abbba".to_vec(), b"ababab".to_vec()])
        .collect();
    for n in &needles {
        let finder = Finder::new(n).into_owned();
        for h in short.iter().chain(&long) {
            let want = first_window(h, n);
            assert_eq!(find(h, n), want, "find {:?} in {:?}", n, h);
            assert_eq!(find_lit(h, &finder), want, "find_lit {:?} in {:?}", n, h);
        }
    }
}

/// The fields are `str::split`'s: left to right, non-overlapping, one field
/// when the delimiter never occurs.
#[test]
fn fields_are_the_split_on_the_delimiter() {
    for s in words(b"ab,", 7) {
        let s = String::from_utf8(s).unwrap();
        for d in [",", "a", "ab", ",,", "ba,"] {
            let got: Vec<&str> = fields(s.as_bytes(), d.as_bytes()).map(|(a, b)| &s[a..b]).collect();
            assert_eq!(got, s.split(d).collect::<Vec<_>>(), "{s:?} on {d:?}");
        }
    }
}