};

fn last_commit_comparison(c: &mut Criterion) {

        .expect("Could not retrieve ./data/git-platinum as git repository");

    let rev = Branch::local("master");

}

fn init_repository_or_exit(path_to_repo: &str) -> git::Repository {

        Ok(repo) => repo,

        Err(e) => {

            println!("Failed to create repository: {:?}", e);

}

impl Repository {

    ///

    /// # Errors

    ///

    /// * [`Error::Git`]

        git2::Repository::open(repo_uri)

            .map(Repository)

            .map_err(Error::from)

    }

    /// Since our operations are read-only when it comes to surfing a repository

    /// we have a separate struct called [`RepositoryRef`]. This turns an owned

    pub fn as_ref(&'_ self) -> RepositoryRef<'_> {

        RepositoryRef { repo_ref: &self.0 }

    }

#[test]

// An issue with submodules, see: https://github.com/radicle-dev/radicle-surf/issues/54

fn test_submodule_failure() {

    repo.as_ref().snapshot(&Branch::local("main")).unwrap();

}

    #[test]

    fn switch_to_banana() -> Result<(), Error> {

        let repo = repo.as_ref();

        let history_master = repo.history(&Branch::local("master"))?;

        repo.switch_namespace("golden")?;

    #[test]

    fn me_namespace() -> Result<(), Error> {

        let repo = repo.as_ref();

        let history = repo.history(&Branch::local("master"))?;

    #[test]

    fn golden_namespace() -> Result<(), Error> {

        let repo = repo.as_ref();

        let history = repo.history(&Branch::local("master"))?;

    #[test]

    fn silver_namespace() -> Result<(), Error> {

        let repo = repo.as_ref();

        let history = repo.history(&Branch::local("master"))?;

    // * Expand "Options" and select "clean checkout".

    #[test]

    fn _master() -> Result<(), Error> {

        let repo = repo.as_ref();

        let mut history = repo.history(&Branch::remote("master", "origin"))?;

    #[test]

    fn commit() -> Result<(), Error> {

        let repo = repo.as_ref();

        let rev = Oid::from_str("3873745c8f6ffb45c990eb23b491d4b4b6182f95")?;

        let mut history = repo.history(rev)?;

    #[test]

    fn commit_parents() -> Result<(), Error> {

        let repo = repo.as_ref();

        let rev = Oid::from_str("3873745c8f6ffb45c990eb23b491d4b4b6182f95")?;

        let history = repo.history(rev)?;

    #[test]

    fn commit_short() -> Result<(), Error> {

        let repo = repo.as_ref();

        let rev = repo.oid("3873745c8")?;

        let mut history = repo.history(rev)?;

    #[test]

    fn tag() -> Result<(), Error> {

        let repo = repo.as_ref();

        let rev = TagName::new("v0.2.0")?;

        let history = repo.history(&rev)?;

    #[test]

    fn readme_missing_and_memory() {

            .expect("Could not retrieve ./data/git-platinum as git repository");

        let oid =

            Oid::from_str("d3464e33d75c75c99bfb90fa2e9d16efc0b7d0e3").expect("Failed to parse SHA");

    #[test]

    fn folder_svelte() {

            .expect("Could not retrieve ./data/git-platinum as git repository");

        // Check that last commit is the actual last commit even if head commit differs.

        let oid =

    #[test]

    fn nest_directory() {

            .expect("Could not retrieve ./data/git-platinum as git repository");

        // Check that last commit is the actual last commit even if head commit differs.

        let oid =

    #[test]

    #[cfg(not(windows))]

    fn can_get_last_commit_for_special_filenames() {

            .expect("Could not retrieve ./data/git-platinum as git repository");

        // Check that last commit is the actual last commit even if head commit differs.

    #[test]

    fn root() {

            .expect("Could not retrieve ./data/git-platinum as git repository");

        let rev = Branch::local("master");

        let root_last_commit_id = repo

    #[test]

    fn binary_file() {

            .expect("Could not retrieve ./data/git-platinum as git repository");

        let repo = repo.as_ref();

        let history = repo.history(&Branch::local("dev")).unwrap();

    #[test]

    fn test_initial_diff() -> Result<(), Error> {

        let repo = repo.as_ref();

        let oid = Oid::from_str("d3464e33d75c75c99bfb90fa2e9d16efc0b7d0e3")?;

        let commit = repo.commit(oid).unwrap();

    #[test]

    fn test_diff_of_rev() -> Result<(), Error> {

        let repo = repo.as_ref();

        let diff = repo.diff_from_parent("80bacafba303bf0cdf6142921f430ff265f25095")?;

        assert_eq!(diff.created.len(), 0);

    #[test]

    fn test_diff() -> Result<(), Error> {

        let repo = repo.as_ref();

        let oid = "80bacafba303bf0cdf6142921f430ff265f25095";

        let commit = repo.commit(oid).unwrap();

    #[test]

    fn test_branch_diff() -> Result<(), Error> {

        let repo = repo.as_ref();

        let diff = repo.diff(&Branch::local("master"), &Branch::local("dev"))?;

    #[test]

    fn basic_test() -> Result<(), Error> {

        let locked_repo: MutexGuard<Repository> = shared_repo.lock().unwrap();

        let mut branches = locked_repo

            .as_ref()

    #[test]

    fn test_branches() {

        let repo = repo.as_ref();

        let branches = repo.branches(&Glob::heads("*").unwrap()).unwrap();

        for b in branches {

    #[test]

    fn test_tag_snapshot() {

        let repo_ref = repo.as_ref();

        let tags = repo_ref

            .tags(&Glob::tags("*").unwrap())

    #[test]

    fn test_namespaces() {

        let repo = repo.as_ref();

        let namespaces = repo.namespaces(&Glob::namespaces("*").unwrap()).unwrap();

        assert_eq!(namespaces.count(), 3);

    #[test]

    fn iterate_root_dir_recursive() {

        let repo = repo.as_ref();

        let root_dir = repo.snapshot(&Branch::local("master")).unwrap();

        let count = println_dir(&root_dir, 0);

    #[test]

    fn test_file_history() {

        let repo = repo.as_ref();

        let history = repo.history(&Branch::local("dev")).unwrap();

        let path = unsound::path::new("README.md");