pub use git_testtools::Result; mod parse {    use std::collections::HashMap;     use bstr::{BStr, BString, ByteSlice};    use git_attributes::State;    use git_pathspec::{MagicSignature, MatchMode, Pattern};    use once_cell::sync::Lazy;     #[derive(Debug, Clone, PartialEq, Eq)]    struct PatternForTesting {        path: BString,        signature: MagicSignature,        search_mode: MatchMode,        attributes: Vec<(BString, State)>,    }     impl From<Pattern> for PatternForTesting {        fn from(p: Pattern) -> Self {            PatternForTesting {                path: p.path,                signature: p.signature,                search_mode: p.search_mode,                attributes: p                    .attributes                    .into_iter()                    .map(|attr| (attr.name.as_str().into(), attr.state))                    .collect(),            }        }    }     static BASELINE: Lazy<HashMap<BString, usize>> = Lazy::new(|| {        let base = git_testtools::scripted_fixture_read_only("generate_pathspec_baseline.sh").unwrap();         (|| -> crate::Result<_> {            let mut map = HashMap::new();            let baseline = std::fs::read(base.join("baseline.git"))?;            let mut lines = baseline.lines();            while let Some(spec) = lines.next() {                let exit_code = lines.next().expect("two lines per baseline").to_str()?.parse()?;                map.insert(spec.into(), exit_code);            }            Ok(map)        })()        .unwrap()    });     #[test]    fn baseline() {        for (pattern, exit_code) in BASELINE.iter() {            let res = git_pathspec::parse(pattern);            assert_eq!(                res.is_ok(),                *exit_code == 0,                "{pattern:?} disagrees with baseline: {res:?}"            )        }    }     mod succeed {        use git_attributes::State;        use git_pathspec::{MagicSignature, MatchMode};         use crate::parse::{            check_valid_inputs, pat, pat_with_attrs, pat_with_path, pat_with_path_and_sig, pat_with_search_mode,            pat_with_sig,        };         #[test]        fn there_is_no_pathspec_pathspec() {            check_valid_inputs(Some((":", pat_with_attrs(vec![]))));        }         #[test]        fn repeated_matcher_keywords() {            let input = vec![                (":(glob,glob)", pat_with_search_mode(MatchMode::PathAwareGlob)),                (":(literal,literal)", pat_with_search_mode(MatchMode::Literal)),                (":(top,top)", pat_with_sig(MagicSignature::TOP)),                (":(icase,icase)", pat_with_sig(MagicSignature::ICASE)),                (":(attr,attr)", pat_with_attrs(vec![])),                (":!^(exclude,exclude)", pat_with_sig(MagicSignature::EXCLUDE)),            ];             check_valid_inputs(input);        }         #[test]        fn empty_signatures() {            let inputs = vec![                (".", pat_with_path(".")),                ("some/path", pat_with_path("some/path")),                (":some/path", pat_with_path("some/path")),                (":()some/path", pat_with_path("some/path")),                ("::some/path", pat_with_path("some/path")),                (":::some/path", pat_with_path(":some/path")),                (":():some/path", pat_with_path(":some/path")),            ];             check_valid_inputs(inputs)        }         #[test]        fn whitespace_in_pathspec() {            let inputs = vec![                (" some/path", pat_with_path(" some/path")),                ("some/ path", pat_with_path("some/ path")),                ("some/path ", pat_with_path("some/path ")),                (": some/path", pat_with_path(" some/path")),                (": !some/path", pat_with_path(" !some/path")),                (": :some/path", pat_with_path(" :some/path")),                (": ()some/path", pat_with_path(" ()some/path")),                (                    ":! some/path",                    pat_with_path_and_sig(" some/path", MagicSignature::EXCLUDE),                ),            ];             check_valid_inputs(inputs)        }         #[test]        fn short_signatures() {            let inputs = vec![                (":/some/path", pat_with_path_and_sig("some/path", MagicSignature::TOP)),                (                    ":^some/path",                    pat_with_path_and_sig("some/path", MagicSignature::EXCLUDE),                ),                (                    ":!some/path",                    pat_with_path_and_sig("some/path", MagicSignature::EXCLUDE),                ),                (                    ":/!some/path",                    pat_with_path_and_sig("some/path", MagicSignature::TOP | MagicSignature::EXCLUDE),                ),                (                    ":!/^/:some/path",                    pat_with_path_and_sig("some/path", MagicSignature::TOP | MagicSignature::EXCLUDE),                ),            ];             check_valid_inputs(inputs)        }         #[test]        fn signatures_and_searchmodes() {            let inputs = vec![                (":(top)", pat_with_sig(MagicSignature::TOP)),                (":(icase)", pat_with_sig(MagicSignature::ICASE)),                (":(attr)", pat_with_path("")),                (":(exclude)", pat_with_sig(MagicSignature::EXCLUDE)),                (":(literal)", pat_with_search_mode(MatchMode::Literal)),                (":(glob)", pat_with_search_mode(MatchMode::PathAwareGlob)),                (                    ":(top,exclude)",                    pat_with_sig(MagicSignature::TOP | MagicSignature::EXCLUDE),                ),                (                    ":(icase,literal)",                    pat("", MagicSignature::ICASE, MatchMode::Literal, vec![]),                ),                (                    ":!(literal)some/*path",                    pat("some/*path", MagicSignature::EXCLUDE, MatchMode::Literal, vec![]),                ),                (                    ":(top,literal,icase,attr,exclude)some/path",                    pat("some/path", MagicSignature::all(), MatchMode::Literal, vec![]),                ),                (                    ":(top,glob,icase,attr,exclude)some/path",                    pat("some/path", MagicSignature::all(), MatchMode::PathAwareGlob, vec![]),                ),            ];             check_valid_inputs(inputs);        }         #[test]        fn attributes_in_signature() {            let inputs = vec![                (":(attr:someAttr)", pat_with_attrs(vec![("someAttr", State::Set)])),                (                    ":(attr:!someAttr)",                    pat_with_attrs(vec![("someAttr", State::Unspecified)]),                ),                (":(attr:-someAttr)", pat_with_attrs(vec![("someAttr", State::Unset)])),                (                    ":(attr:someAttr=value)",                    pat_with_attrs(vec![("someAttr", State::Value("value".into()))]),                ),                (                    ":(attr:a=one b=)",                    pat_with_attrs(vec![("a", State::Value("one".into())), ("b", State::Value("".into()))]),                ),                (                    ":(attr:a= b=two)",                    pat_with_attrs(vec![("a", State::Value("".into())), ("b", State::Value("two".into()))]),                ),                (                    ":(attr:a=one b=two)",                    pat_with_attrs(vec![                        ("a", State::Value("one".into())),                        ("b", State::Value("two".into())),                    ]),                ),                (                    ":(attr:a=one   b=two)",                    pat_with_attrs(vec![                        ("a", State::Value("one".into())),                        ("b", State::Value("two".into())),                    ]),                ),                (                    ":(attr:someAttr anotherAttr)",                    pat_with_attrs(vec![("someAttr", State::Set), ("anotherAttr", State::Set)]),                ),            ];             check_valid_inputs(inputs)        }         #[test]        fn attributes_with_escape_chars_in_state_values() {            let inputs = vec![                (                    r":(attr:v=one\-)",                    pat_with_attrs(vec![("v", State::Value(r"one-".into()))]),                ),                (                    r":(attr:v=one\_)",                    pat_with_attrs(vec![("v", State::Value(r"one_".into()))]),                ),                (                    r":(attr:v=one\,)",                    pat_with_attrs(vec![("v", State::Value(r"one,".into()))]),                ),                (                    r":(attr:v=one\,two\,three)",                    pat_with_attrs(vec![("v", State::Value(r"one,two,three".into()))]),                ),                (                    r":(attr:a=\d b= c=\d)",                    pat_with_attrs(vec![                        ("a", State::Value(r"d".into())),                        ("b", State::Value(r"".into())),                        ("c", State::Value(r"d".into())),                    ]),                ),            ];             check_valid_inputs(inputs)        }    }     mod fail {        use git_pathspec::parse::Error;         use crate::parse::check_against_baseline;         #[test]        fn empty_input() {            let input = "";             assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");             let output = git_pathspec::parse(input.as_bytes());            assert!(output.is_err());            assert!(matches!(output.unwrap_err(), Error::EmptyString));        }         #[test]        fn invalid_short_signatures() {            let inputs = vec![                ":\"()", ":#()", ":%()", ":&()", ":'()", ":,()", ":-()", ":;()", ":<()", ":=()", ":>()", ":@()",                ":_()", ":`()", ":~()",            ];             for input in inputs.into_iter() {                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");                 let output = git_pathspec::parse(input.as_bytes());                assert!(output.is_err());                assert!(matches!(output.unwrap_err(), Error::Unimplemented { .. }));            }        }         #[test]        fn invalid_keywords() {            let inputs = vec![                ":( )some/path",                ":(tp)some/path",                ":(top, exclude)some/path",                ":(top,exclude,icse)some/path",            ];             for input in inputs.into_iter() {                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");                 let output = git_pathspec::parse(input.as_bytes());                assert!(output.is_err());                assert!(matches!(output.unwrap_err(), Error::InvalidKeyword { .. }));            }        }         #[test]        fn invalid_attributes() {            let inputs = vec![                ":(attr:+invalidAttr)some/path",                ":(attr:validAttr +invalidAttr)some/path",                ":(attr:+invalidAttr,attr:valid)some/path",                r":(attr:inva\lid)some/path",            ];             for input in inputs {                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");                 let output = git_pathspec::parse(input.as_bytes());                assert!(output.is_err(), "This pathspec did not produce an error {input}");                assert!(matches!(output.unwrap_err(), Error::InvalidAttribute { .. }));            }        }         #[test]        fn invalid_attribute_values() {            let inputs = vec![                r":(attr:v=inva#lid)some/path",                r":(attr:v=inva\\lid)some/path",                r":(attr:v=invalid\\)some/path",                r":(attr:v=invalid\#)some/path",                r":(attr:v=inva\=lid)some/path",                r":(attr:a=valid b=inva\#lid)some/path",                ":(attr:v=val��)",                ":(attr:pr=pre��x:,)�",            ];             for input in inputs {                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");                 let output = git_pathspec::parse(input.as_bytes());                assert!(output.is_err(), "This pathspec did not produce an error {input}");                assert!(                    matches!(output.unwrap_err(), Error::InvalidAttributeValue { .. }),                    "Errors did not match for pathspec: {input}"                );            }        }         #[test]        fn escape_character_at_end_of_attribute_value() {            let inputs = vec![                r":(attr:v=invalid\)some/path",                r":(attr:v=invalid\ )some/path",                r":(attr:v=invalid\ valid)some/path",            ];             for input in inputs {                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");                 let output = git_pathspec::parse(input.as_bytes());                assert!(output.is_err(), "This pathspec did not produce an error {input}");                assert!(matches!(output.unwrap_err(), Error::TrailingEscapeCharacter));            }        }         #[test]        fn empty_attribute_specification() {            let input = ":(attr:)";             assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");             let output = git_pathspec::parse(input.as_bytes());            assert!(output.is_err());            assert!(matches!(output.unwrap_err(), Error::EmptyAttribute));        }         #[test]        fn multiple_attribute_specifications() {            let input = ":(attr:one,attr:two)some/path";             assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");             let output = git_pathspec::parse(input.as_bytes());            assert!(output.is_err());            assert!(matches!(output.unwrap_err(), Error::MultipleAttributeSpecifications));        }         #[test]        fn missing_parentheses() {            let input = ":(top";             assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");             let output = git_pathspec::parse(input.as_bytes());            assert!(output.is_err());            assert!(matches!(output.unwrap_err(), Error::MissingClosingParenthesis { .. }));        }         #[test]        fn glob_and_literal_keywords_present() {            let input = ":(glob,literal)some/path";             assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");             let output = git_pathspec::parse(input.as_bytes());            assert!(output.is_err());            assert!(matches!(output.unwrap_err(), Error::IncompatibleSearchModes));        }    }     fn check_valid_inputs<'a>(inputs: impl IntoIterator<Item = (&'a str, PatternForTesting)>) {        for (input, expected) in inputs.into_iter() {            assert!(                check_against_baseline(input),                "This pathspec is invalid in git: {input}"            );             let pattern: PatternForTesting = git_pathspec::parse(input.as_bytes())                .unwrap_or_else(|_| panic!("parsing should not fail with pathspec {input}"))                .into();            assert_eq!(pattern, expected, "while checking input: \"{input}\"");        }    }     fn pat_with_path(path: &str) -> PatternForTesting {        pat_with_path_and_sig(path, MagicSignature::empty())    }     fn pat_with_path_and_sig(path: &str, signature: MagicSignature) -> PatternForTesting {        pat(path, signature, MatchMode::ShellGlob, vec![])    }     fn pat_with_sig(signature: MagicSignature) -> PatternForTesting {        pat("", signature, MatchMode::ShellGlob, vec![])    }     fn pat_with_attrs(attrs: Vec<(&'static str, State)>) -> PatternForTesting {        pat("", MagicSignature::empty(), MatchMode::ShellGlob, attrs)    }     fn pat_with_search_mode(search_mode: MatchMode) -> PatternForTesting {        pat("", MagicSignature::empty(), search_mode, vec![])    }     fn pat(        path: &str,        signature: MagicSignature,        search_mode: MatchMode,        attributes: Vec<(&str, State)>,    ) -> PatternForTesting {        PatternForTesting {            path: path.into(),            signature,            search_mode,            attributes: attributes                .into_iter()                .map(|(attr, state)| (attr.into(), state))                .collect(),        }    }     fn check_against_baseline(pathspec: &str) -> bool {        let key: &BStr = pathspec.into();        let base = BASELINE            .get(key)            .unwrap_or_else(|| panic!("missing baseline for pathspec: {pathspec:?}"));        *base == 0    }}