bulloak 0.9.2

A Solidity test generator based on the Branching Tree Technique. 
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use std::path::PathBuf;

use glob::glob;

pub(crate) fn expand_glob(
    input: PathBuf,
) -> anyhow::Result<impl Iterator<Item = PathBuf>> {
    let input = input.to_string_lossy();
    let paths = glob(&input)?.filter_map(Result::ok);
    Ok(paths)
}

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use super::expand_glob;

    /// Helper to collect and sort the output.
    fn sorted_matches(pattern: &str) -> Vec<String> {
        let mut v: Vec<_> = expand_glob(PathBuf::from(pattern))
            .unwrap()
            .map(|p| p.to_string_lossy().into_owned())
            .collect();
        v.sort();
        v
    }

    #[test]
    fn literal_path_round_trips() {
        // This crate has a Cargo.toml in its root.
        let out = sorted_matches("Cargo.toml");
        assert_eq!(out, vec!["Cargo.toml".to_string()]);
    }

    #[test]
    fn no_such_file_yields_empty() {
        let out = sorted_matches("no-such-file-xyz.tree");
        assert!(out.is_empty());
    }

    #[test]
    fn simple_star_glob() {
        // Match all .rs files in src/
        let out = sorted_matches("src/*.rs");
        assert!(out.iter().any(|e| e.ends_with("main.rs")));
        assert!(out.iter().any(|e| e.ends_with("check.rs")));
    }

    #[test]
    fn recursive_double_star_glob() {
        // `tests` directory has .tree files under tests/scaffold/.
        let out = sorted_matches("tests/scaffold/**/*.tree");
        assert!(out.iter().any(|e| e.ends_with("basic.tree")));
        assert!(out.iter().any(|e| e.ends_with("complex.tree")));
    }

    #[test]
    fn forward_slash_glob_works_everywhere() {
        let out = sorted_matches("tests/scaffold/*.tree");
        assert!(out.iter().any(|e| e.ends_with("basic.tree")));
    }

    #[test]
    #[cfg(windows)]
    fn backslash_glob_works_the_same() {
        let fwd = sorted_matches("tests/scaffold/*.tree");
        let bwd = sorted_matches("tests\\scaffold\\*.tree");
        assert_eq!(
            fwd, bwd,
            "backslash‐based glob must match forward‐slash one"
        );
    }

    #[test]
    fn invalid_pattern_returns_error() {
        // Invalid glob syntax (unmatched '[') must return Err.
        let bad = PathBuf::from("tests/scaffold/*[.tree");
        let res = expand_glob(bad);
        assert!(res.is_err(), "expected invalid glob to Err");
    }
}