mod from_refs {    use gix_protocol::fetch::{RefMap, refmap};    use gix_transport::client::Capabilities;     #[test]    fn sha1_capability_is_honored() {        let caps = caps_with(b"symref=HEAD:refs/heads/main object-format=sha1 agent=git/2.54.0");        let map = RefMap::from_refs(Vec::new(), &caps, ctx()).expect("known format");        assert_eq!(            map.object_hash,            gix_hash::Kind::Sha1,            "An `object-format=sha1` capability resolves to `gix_hash::Kind::Sha1` on the resulting RefMap"        );    }     #[cfg(feature = "sha256")]    #[test]    fn sha256_capability_is_honored() {        let caps = caps_with(b"symref=HEAD:refs/heads/main object-format=sha256 agent=git/2.54.0");        let map = RefMap::from_refs(Vec::new(), &caps, ctx()).expect("known format");        assert_eq!(            map.object_hash,            gix_hash::Kind::Sha256,            "An `object-format=sha256` capability resolves to `gix_hash::Kind::Sha256`, so Sha256 servers            can be talked to without falling back to Sha1"        );    }     #[test]    fn unknown_object_format_errors() {        let caps = caps_with(b"symref=HEAD:refs/heads/main object-format=sha999 agent=git/2.54.0");        let err = RefMap::from_refs(Vec::new(), &caps, ctx()).expect_err("unknown format must error");        assert!(            matches!(err, refmap::init::Error::UnknownObjectFormat { ref format } if format == "sha999"),            "Any `object-format` value we don't recognize must surface as an `UnknownObjectFormat` error            rather than silently defaulting to Sha1, so callers can refuse to fetch from unsupported servers"        );    }     #[test]    fn missing_object_format_defaults_to_sha1() {        let caps = caps_with(b"symref=HEAD:refs/heads/main agent=git/2.54.0");        let map = RefMap::from_refs(Vec::new(), &caps, ctx()).expect("implicit sha1");        assert_eq!(            map.object_hash,            gix_hash::Kind::Sha1,            "Servers that omit `object-format` are implicitly Sha1, so the RefMap should reflect that"        );    }     fn caps_with(after_nul: &[u8]) -> Capabilities {        let mut bytes: Vec<u8> = b"7814e8a05a59c0cf5fb186661d1551c75d1299b5 HEAD\0".to_vec();        bytes.extend_from_slice(after_nul);        Capabilities::from_bytes(&bytes).expect("valid capabilities line").0    }     fn ctx() -> refmap::init::Context {        refmap::init::Context {            fetch_refspecs: Vec::new(),            extra_refspecs: Vec::new(),        }    }} mod is_missing_required_mapping {    use gix_protocol::{        fetch::{            RefMap,            refmap::{Mapping, Source, SpecIndex},        },        handshake::Ref,    };     fn fetch_spec(spec: &str) -> gix_refspec::RefSpec {        gix_refspec::parse(spec.into(), gix_refspec::parse::Operation::Fetch)            .expect("valid")            .to_owned()    }     /// If the server advertised refs but none of them matched at all, callers should treat this as a    /// missing required mapping instead of silently proceeding with an empty result.    ///    /// This covers the case where an exact fetch refspec like `refs/heads/main` was expected to match    /// something on the remote, but the only advertised ref was unrelated.    #[test]    fn is_true_if_remote_refs_exist_but_nothing_mapped() {        let map = RefMap {            refspecs: vec![fetch_spec("refs/heads/main")],            remote_refs: vec![Ref::Direct {                full_ref_name: "refs/heads/other".into(),                object: gix_hash::ObjectId::null(gix_hash::Kind::Sha1),            }],            object_hash: gix_hash::Kind::Sha1,            ..Default::default()        };         assert!(map.is_missing_required_mapping());    }     /// Exact explicit refspecs like `HEAD` still require an explicit mapping, even if unrelated implicit    /// mappings exist due to extra refspecs such as tag following.    ///    /// Returning `true` here ensures callers don't mistake an implicit-only result for a successful match    /// of the user's explicit fetch request.    #[test]    fn is_true_if_only_implicit_mappings_exist_for_exact_refspecs() {        let map = RefMap {            mappings: vec![Mapping {                remote: Source::ObjectId(gix_hash::ObjectId::null(gix_hash::Kind::Sha1)),                local: Some("refs/remotes/origin/main".into()),                spec_index: SpecIndex::Implicit(0),            }],            refspecs: vec![fetch_spec("HEAD")],            extra_refspecs: vec![fetch_spec("refs/tags/*:refs/tags/*")],            object_hash: gix_hash::Kind::Sha1,            ..Default::default()        };         assert!(map.is_missing_required_mapping());    }     /// Wildcard refspecs are allowed to match nothing without being considered an error.    ///    /// They express interest in a namespace rather than in one required ref, so an empty result here means    /// "nothing matched" instead of "a required mapping is missing".    #[test]    fn is_false_if_wildcards_are_the_only_unmatched_explicit_refspecs() {        let map = RefMap {            refspecs: vec![fetch_spec("refs/heads/*:refs/remotes/origin/*")],            object_hash: gix_hash::Kind::Sha1,            ..Default::default()        };         assert!(!map.is_missing_required_mapping());    }     /// Once at least one explicit refspec produced a mapping, the helper must report success.    ///    /// This is the common case of an exact refspec matching as intended, so callers should continue with    /// negotiation or ref updates instead of raising a no-mapping error.    #[test]    fn is_false_if_an_explicit_mapping_exists() {        let map = RefMap {            mappings: vec![Mapping {                remote: Source::ObjectId(gix_hash::ObjectId::null(gix_hash::Kind::Sha1)),                local: Some("refs/remotes/origin/main".into()),                spec_index: SpecIndex::ExplicitInRemote(0),            }],            refspecs: vec![fetch_spec("refs/heads/main")],            object_hash: gix_hash::Kind::Sha1,            ..Default::default()        };         assert!(!map.is_missing_required_mapping());    }}