use gix_refspec::parse::{Error, Operation}; use crate::parse::try_parse; #[test]fn empty() {    assert!(matches!(try_parse("", Operation::Push).unwrap_err(), Error::Empty));} #[test]fn empty_component() {    assert!(matches!(        try_parse("refs/heads/test:refs/remotes//test", Operation::Fetch).unwrap_err(),        Error::ReferenceName(gix_validate::reference::name::Error::RepeatedSlash)    ));} #[test]fn whitespace() {    assert!(matches!(        try_parse("refs/heads/test:refs/remotes/ /test", Operation::Fetch).unwrap_err(),        Error::ReferenceName(gix_validate::reference::name::Error::InvalidByte { .. })    ));} #[test]fn complex_patterns_with_more_than_one_asterisk() {    // For one-sided refspecs, complex patterns are now allowed    for op in [Operation::Fetch, Operation::Push] {        assert!(try_parse("a/*/c/*", op).is_ok());    }     // For two-sided refspecs, complex patterns should still fail    for op in [Operation::Fetch, Operation::Push] {        for spec in ["a/*/c/*:x/*/y/*", "a**:**b", "+:**/"] {            assert!(matches!(                try_parse(spec, op).unwrap_err(),                Error::PatternUnsupported { .. }            ));        }    }     // Negative specs with partial patterns still fail.    assert!(matches!(        try_parse("^*/*", Operation::Fetch).unwrap_err(),        Error::NegativePartialName    ));    // Negative refspec patterns follow Git's single-asterisk refspec-pattern rule.    for op in [Operation::Fetch, Operation::Push] {        assert!(matches!(            try_parse("^refs/heads/qa/*/*", op).unwrap_err(),            Error::PatternUnsupported { .. }        ));        for spec in [            "^refs/heads/a*?",            "^refs/heads/a[bc]*",            "^refs/heads/*..bad",            "^refs/heads/*/",        ] {            assert!(                matches!(try_parse(spec, op).unwrap_err(), Error::ReferenceName(_)),                "{spec}"            );        }    }} #[test]fn both_sides_need_pattern_if_one_uses_it() {    // For two-sided refspecs, both sides still need patterns if one uses it    for op in [Operation::Fetch, Operation::Push] {        for spec in [":a/*", "+:a/*", "a*:b/c", "a:b/*"] {            assert!(                matches!(try_parse(spec, op).unwrap_err(), Error::PatternUnbalanced),                "{}",                spec            );        }    }     // One-sided refspecs with patterns are now allowed    for op in [Operation::Fetch, Operation::Push] {        assert!(try_parse("refs/*/a", op).is_ok());    }} #[test]fn push_to_empty() {    assert!(matches!(        try_parse("HEAD:", Operation::Push).unwrap_err(),        Error::PushToEmpty    ));} #[test]fn fuzzed() {    let input =        include_bytes!("../../fixtures/fuzzed/clusterfuzz-testcase-minimized-gix-refspec-parse-4658733962887168");    drop(gix_refspec::parse(input.into(), gix_refspec::parse::Operation::Fetch).unwrap_err());    drop(gix_refspec::parse(input.into(), gix_refspec::parse::Operation::Push).unwrap_err());}