use std::path::Path; use gix_testtools::tempfile::{TempDir, tempdir};use gix_worktree::{Stack, stack}; const IS_FILE: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::FILE);const IS_DIR: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::DIR);const IS_SYMLINK: Option<gix_index::entry::Mode> = Some(gix_index::entry::Mode::SYMLINK); #[test]fn root_is_assumed_to_exist_and_files_in_root_do_not_create_directory() -> crate::Result {    let dir = tempdir()?;    let mut cache = Stack::new(        dir.path().join("non-existing-root"),        stack::State::for_checkout(false, Default::default(), Default::default()),        Default::default(),        Vec::new(),        Default::default(),    );    assert_eq!(cache.statistics().delegate.num_mkdir_calls, 0);     let path = cache.at_path("hello", IS_FILE, &gix_object::find::Never)?.path();    assert!(!path.parent().unwrap().exists(), "prefix itself is never created");    assert_eq!(cache.statistics().delegate.num_mkdir_calls, 0);    Ok(())} #[test]fn directory_paths_are_created_in_full() {    let (mut cache, _tmp) = new_cache();     for (name, mode) in [        ("dir", IS_DIR),        ("submodule", IS_DIR),        ("file", IS_FILE),        ("exe", IS_FILE),        ("link", None),    ] {        let path = cache            .at_path(Path::new("dir").join(name), mode, &gix_object::find::Never)            .unwrap()            .path();        assert!(path.parent().unwrap().is_dir(), "dir exists");    }     assert_eq!(cache.statistics().delegate.num_mkdir_calls, 3);} #[test]fn existing_directories_are_fine() -> crate::Result {    let (mut cache, tmp) = new_cache();    std::fs::create_dir(tmp.path().join("dir"))?;     let path = cache.at_path("dir/file", IS_FILE, &gix_object::find::Never)?.path();    assert!(path.parent().unwrap().is_dir(), "directory is still present");    assert!(!path.exists(), "it won't create the file");    assert_eq!(cache.statistics().delegate.num_mkdir_calls, 1);    Ok(())} #[test]fn validation_to_each_component() -> crate::Result {    let (mut cache, tmp) = new_cache();     let err = cache        .at_path("valid/.gIt", IS_FILE, &gix_object::find::Never)        .unwrap_err();    assert_eq!(        cache.statistics().delegate.num_mkdir_calls,        1,        "the valid directory was created"    );    assert!(tmp.path().join("valid").is_dir(), "it was actually created");    assert_eq!(err.to_string(), "The .git name may never be used");    Ok(())} #[test]fn symlinks_or_files_in_path_are_forbidden_or_unlinked_when_forced() -> crate::Result {    let (mut cache, tmp) = new_cache();    let forbidden = tmp.path().join("forbidden");    std::fs::create_dir(&forbidden)?;    symlink::symlink_dir(&forbidden, tmp.path().join("link-to-dir"))?;    std::fs::write(tmp.path().join("file-in-dir"), [])?;     for dirname in &["file-in-dir", "link-to-dir"] {        if let stack::State::CreateDirectoryAndAttributesStack {            unlink_on_collision, ..        } = cache.state_mut()        {            *unlink_on_collision = false;        }        let relative_path = format!("{dirname}/file");        assert_eq!(            cache                .at_path(&*relative_path, IS_FILE, &gix_object::find::Never)                .unwrap_err()                .kind(),            std::io::ErrorKind::AlreadyExists        );    }    assert_eq!(        cache.statistics().delegate.num_mkdir_calls,        2,        "it tries to create each directory once, but it's a file"    );    cache.take_statistics();    for dirname in &["link-to-dir", "file-in-dir"] {        if let stack::State::CreateDirectoryAndAttributesStack {            unlink_on_collision, ..        } = cache.state_mut()        {            *unlink_on_collision = true;        }        let relative_path = format!("{dirname}/file");        let path = cache            .at_path(&*relative_path, IS_FILE, &gix_object::find::Never)?            .path();        assert!(path.parent().unwrap().is_dir(), "directory was forcefully created");        assert!(!path.exists());    }    assert_eq!(        cache.statistics().delegate.num_mkdir_calls,        4,        "like before, but it unlinks what's there and tries again"    );    Ok(())} #[test]fn symlink_cached_as_file_is_revalidated_before_use_as_directory() -> crate::Result {    let (mut cache, tmp) = new_cache();    let forbidden = tmp.path().join("forbidden");    std::fs::create_dir(&forbidden)?;     let link_path = cache        .at_path("link", IS_SYMLINK, &gix_object::find::Never)?        .path()        .to_owned();    symlink::symlink_dir(&forbidden, &link_path)?;     let err = cache        .at_path("link/file", IS_SYMLINK, &gix_object::find::Never)        .unwrap_err();    assert_eq!(err.kind(), std::io::ErrorKind::AlreadyExists);    assert!(        link_path.symlink_metadata()?.file_type().is_symlink(),        "the existing symlink must remain in place when collisions are forbidden"    );    Ok(())} #[test]fn symlink_cached_as_file_is_unlinked_before_use_as_directory_when_forced() -> crate::Result {    let (mut cache, tmp) = new_cache();    let forbidden = tmp.path().join("forbidden");    std::fs::create_dir(&forbidden)?;     let link_path = cache        .at_path("link", IS_SYMLINK, &gix_object::find::Never)?        .path()        .to_owned();    symlink::symlink_dir(&forbidden, &link_path)?;    if let stack::State::CreateDirectoryAndAttributesStack {        unlink_on_collision, ..    } = cache.state_mut()    {        *unlink_on_collision = true;    }     let path = cache.at_path("link/file", IS_SYMLINK, &gix_object::find::Never)?.path();    assert_eq!(path, tmp.path().join("link").join("file"));    assert!(        link_path.symlink_metadata()?.is_dir(),        "the existing symlink must be replaced with a directory when collisions may be unlinked"    );    Ok(())} fn new_cache() -> (Stack, TempDir) {    let dir = tempdir().unwrap();    let cache = Stack::new(        dir.path(),        stack::State::for_checkout(false, Default::default(), Default::default()),        Default::default(),        Vec::new(),        Default::default(),    );    (cache, dir)}