mod interpolate {    use std::path::{Path, PathBuf};     use gix_config_value::path;     #[test]    fn backslash_is_not_special_and_they_are_not_escaping_anything() -> crate::Result {        for path in [r"C:\foo\bar", "/foo/bar"] {            let actual = gix_config_value::Path::from(path).interpolate(Default::default())?;            assert_eq!(actual, Path::new(path));        }        Ok(())    }     #[test]    fn empty_path_is_error() {        assert!(matches!(            interpolate_without_context(""),            Err(path::interpolate::Error::Missing { what: "path" })        ));    }     #[test]    fn prefix_substitutes_git_install_dir() {        for git_install_dir in &["/tmp/git", r"C:\git"] {            for (val, expected) in &[("%(prefix)/foo/bar", "foo/bar"), (r"%(prefix)/foo\bar", r"foo\bar")] {                let expected =                    std::path::PathBuf::from(format!("{}{}{}", git_install_dir, std::path::MAIN_SEPARATOR, expected));                assert_eq!(                    gix_config_value::Path::from(*val)                        .interpolate(path::interpolate::Context {                            git_install_dir: Path::new(git_install_dir).into(),                            ..Default::default()                        })                        .unwrap(),                    expected,                    "prefix interpolation keeps separators as they are"                );            }        }    }     #[test]    fn prefix_substitution_skipped_with_dot_slash() {        let path = "./%(prefix)/foo/bar";        let git_install_dir = "/tmp/git";        assert_eq!(            gix_config_value::Path::from(path)                .interpolate(path::interpolate::Context {                    git_install_dir: Path::new(git_install_dir).into(),                    ..Default::default()                })                .unwrap(),            Path::new(path)        );    }     #[test]    fn tilde_alone_does_not_interpolate() -> crate::Result {        assert_eq!(interpolate_without_context("~")?, Path::new("~"));        Ok(())    }     #[test]    fn tilde_slash_substitutes_current_user() -> crate::Result {        let path = "~/user/bar";        let home = std::env::current_dir()?;        let expected = home.join("user").join("bar");        assert_eq!(            gix_config_value::Path::from(path)                .interpolate(path::interpolate::Context {                    home_dir: Some(&home),                    home_for_user: Some(home_for_user),                    ..Default::default()                })                .unwrap(),            expected        );        Ok(())    }     #[cfg(any(target_os = "windows", target_os = "android"))]    #[test]    fn tilde_with_given_user_is_unsupported_on_windows_and_android() {        assert!(matches!(            interpolate_without_context("~baz/foo/bar"),            Err(gix_config_value::path::interpolate::Error::UserInterpolationUnsupported)        ));    }     #[cfg(not(any(target_os = "windows", target_os = "android")))]    #[test]    fn tilde_with_given_user() -> crate::Result {        let home = std::env::current_dir()?;         for path_suffix in &["foo/bar", r"foo\bar", ""] {            let path = format!("~user{}{}", std::path::MAIN_SEPARATOR, path_suffix);            let expected = home.join("user").join(path_suffix);             assert_eq!(interpolate_without_context(path)?, expected);        }        Ok(())    }     fn interpolate_without_context(        path: impl AsRef<str>,    ) -> Result<PathBuf, gix_config_value::path::interpolate::Error> {        gix_config_value::Path::from(path.as_ref()).interpolate(path::interpolate::Context {            home_for_user: Some(home_for_user),            ..Default::default()        })    }     fn home_for_user(name: &str) -> Option<PathBuf> {        std::env::current_dir().unwrap().join(name).into()    }} mod optional_prefix {    use std::borrow::Cow;     use bstr::BString;     #[test]    fn cow_inputs_become_owned_paths() {        let borrowed = gix_config_value::Path::from(Cow::Borrowed(bstr::BStr::new("relative/path")));        assert_eq!(            borrowed.value, "relative/path",            "borrowed Cow input is copied into the path"        );         let owned = gix_config_value::Path::from(Cow::Owned(BString::from("relative/path")));        assert_eq!(owned.value, "relative/path", "owned Cow input is moved into the path");    }     #[test]    fn path_without_optional_prefix_is_not_optional() {        let path = gix_config_value::Path::from("/some/path");        assert!(!path.is_optional, "path without prefix should not be optional");        assert_eq!(path.value, "/some/path");    }     #[test]    fn path_with_optional_prefix_is_optional() {        let path = gix_config_value::Path::from(":(optional)/some/path");        assert!(path.is_optional, "path with :(optional) prefix should be optional");        assert_eq!(path.value, "/some/path", "prefix should be stripped");    }     #[test]    fn optional_prefix_with_relative_path() {        let path = gix_config_value::Path::from(":(optional)relative/path");        assert!(path.is_optional);        assert_eq!(path.value, "relative/path");    }     #[test]    fn optional_prefix_with_tilde_expansion() {        let path = gix_config_value::Path::from(":(optional)~/config/file");        assert!(path.is_optional);        assert_eq!(            path.value, "~/config/file",            "tilde should be preserved for interpolation"        );    }     #[test]    fn optional_prefix_with_prefix_substitution() {        let path = gix_config_value::Path::from(":(optional)%(prefix)/share/git");        assert!(path.is_optional);        assert_eq!(            path.value, "%(prefix)/share/git",            "prefix should be preserved for interpolation"        );    }     #[test]    fn optional_prefix_with_windows_path() {        let path = gix_config_value::Path::from(r":(optional)C:\Users\file");        assert!(path.is_optional);        assert_eq!(path.value, r"C:\Users\file");    }     #[test]    fn optional_prefix_followed_by_empty_path() {        let path = gix_config_value::Path::from(":(optional)");        assert!(path.is_optional);        assert_eq!(path.value, "", "empty path after prefix is valid");    }     #[test]    fn partial_optional_string_is_not_treated_as_prefix() {        let path = gix_config_value::Path::from(":(opt)ional/path");        assert!(            !path.is_optional,            "incomplete prefix should not be treated as optional marker"        );        assert_eq!(path.value, ":(opt)ional/path");    }     #[test]    fn optional_prefix_case_sensitive() {        let path = gix_config_value::Path::from(":(OPTIONAL)/some/path");        assert!(!path.is_optional, "prefix should be case-sensitive");        assert_eq!(path.value, ":(OPTIONAL)/some/path");    }     #[test]    fn optional_prefix_with_spaces() {        let path = gix_config_value::Path::from(":(optional) /path/with/space");        assert!(path.is_optional);        assert_eq!(            path.value, " /path/with/space",            "space after prefix should be preserved"        );    }     #[test]    fn owned_path_strips_optional_prefix_in_place() {        let owned_input = bstr::BString::from(":(optional)/some/path");        let path = gix_config_value::Path::from(owned_input);         assert!(path.is_optional);        assert_eq!(path.value, "/some/path");    }}