mod close {     use std::io::Write;     use git_lock::acquire::Fail;     #[test]    fn acquire_close_commit_to_existing_file() -> crate::Result {        let dir = tempfile::tempdir()?;        let resource = dir.path().join("resource-existing.ext");        std::fs::write(&resource, b"old state")?;        let resource_lock = resource.with_extension("ext.lock");        let mut file = git_lock::File::acquire_to_update_resource(&resource, Fail::Immediately, None)?;        assert!(resource_lock.is_file());        file.with_mut(|out| out.write_all(b"hello world"))?;        let mark = file.close()?;        assert_eq!(mark.lock_path(), resource_lock);        assert_eq!(mark.resource_path(), resource);        assert_eq!(mark.commit()?, resource, "returned and initial resource path match");        assert_eq!(            std::fs::read(resource)?,            &b"hello world"[..],            "it created the resource and wrote the data"        );        assert!(!resource_lock.is_file());        Ok(())    }} mod commit {    use git_lock::acquire::Fail;     #[test]    fn failure_to_commit_does_return_a_registered_marker() -> crate::Result {        let dir = tempfile::tempdir()?;        let resource = dir.path().join("resource-existing.ext");        std::fs::create_dir(&resource)?;        let mark = git_lock::Marker::acquire_to_hold_resource(&resource, Fail::Immediately, None)?;        let lock_path = mark.lock_path().to_owned();        assert!(lock_path.is_file(), "the lock is placed");         let err = mark            .commit()            .expect_err("cannot commit onto existing directory, empty or not");        assert!(err.instance.lock_path().is_file(), "the lock is still present");         drop(err);        assert!(            !lock_path.is_file(),            "the lock file is still owned by the lock instance (and ideally still registered, but hard to test)"        );        Ok(())    }     #[test]    fn failure_to_commit_does_return_a_registered_file() -> crate::Result {        let dir = tempfile::tempdir()?;        let resource = dir.path().join("resource-existing.ext");        std::fs::create_dir(&resource)?;        let file = git_lock::File::acquire_to_update_resource(&resource, Fail::Immediately, None)?;        let lock_path = file.lock_path().to_owned();        assert!(lock_path.is_file(), "the lock is placed");         let err = file            .commit()            .expect_err("cannot commit onto existing directory, empty or not");        assert!(err.instance.lock_path().is_file(), "the lock is still present");        std::fs::remove_dir(resource)?;        let (resource, open_file) = err.instance.commit()?;        let mut open_file = open_file.expect("file to be present as no interrupt has messed with us");         assert!(            !lock_path.is_file(),            "the lock was moved into place, now it's the resource"        );         use std::io::Write;        write!(open_file, "hello")?;        drop(open_file);        assert_eq!(            std::fs::read(resource)?,            b"hello".to_vec(),            "and committing returned a writable file handle"        );        Ok(())    }} mod acquire {    use std::io::{ErrorKind, Write};     use git_lock::acquire;     fn fail_immediately() -> git_lock::acquire::Fail {        acquire::Fail::Immediately    }     #[test]    fn lock_create_dir_write_commit() -> crate::Result {        let dir = tempfile::tempdir()?;        let resource = dir.path().join("a").join("resource-nonexisting");        let resource_lock = resource.with_extension("lock");        let mut file =            git_lock::File::acquire_to_update_resource(&resource, fail_immediately(), Some(dir.path().into()))?;        assert_eq!(file.lock_path(), resource_lock);        assert_eq!(file.resource_path(), resource);        assert!(resource_lock.is_file());        file.with_mut(|out| out.write_all(b"hello world"))?;        assert_eq!(file.commit()?.0, resource, "returned and computed resource path match");        assert_eq!(            std::fs::read(resource)?,            &b"hello world"[..],            "it created the resource and wrote the data"        );        assert!(!resource_lock.is_file());        Ok(())    }     #[test]    fn lock_write_drop() -> crate::Result {        let dir = tempfile::tempdir()?;        let resource = dir.path().join("resource-nonexisting.ext");        {            let mut file = git_lock::File::acquire_to_update_resource(&resource, fail_immediately(), None)?;            file.with_mut(|out| out.write_all(b"probably we will be interrupted"))?;        }        assert!(!resource.is_file(), "the file wasn't created");        Ok(())    }     #[test]    fn lock_non_existing_dir_fails() -> crate::Result {        let dir = tempfile::tempdir()?;        let resource = dir.path().join("a").join("resource.ext");        let res = git_lock::File::acquire_to_update_resource(&resource, fail_immediately(), None);        assert!(matches!(res, Err(acquire::Error::Io(err)) if err.kind() == ErrorKind::NotFound));        assert!(dir.path().is_dir(), "it won't meddle with the containing directory");        assert!(!resource.is_file(), "the resource is not created");        assert!(            !resource.parent().unwrap().is_dir(),            "parent dire wasn't created either"        );        Ok(())    }}