Fix macro hygene error in repo_test

Author: foriequal0

src/blame.rs

@@ -290,35 +290,41 @@ mod tests {
     use std::fs::{self, File};
     use std::path::Path;
 
-    repo_test!(smoke, Typical, TypicalWorktree, BareWorktree {
-        let mut index = repo.index().unwrap();
-
-        let root = repo.path().parent().unwrap();
-        fs::create_dir(&root.join("foo")).unwrap();
-        File::create(&root.join("foo/bar")).unwrap();
-        index.add_path(Path::new("foo/bar")).unwrap();
-
-        let id = index.write_tree().unwrap();
-        let tree = repo.find_tree(id).unwrap();
-        let sig = repo.signature().unwrap();
-        let id = repo.refname_to_id("HEAD").unwrap();
-        let parent = repo.find_commit(id).unwrap();
-        let commit = repo
-            .commit(Some("HEAD"), &sig, &sig, "commit", &tree, &[&parent])
-            .unwrap();
-
-        let blame = repo.blame_file(Path::new("foo/bar"), None).unwrap();
-
-        assert_eq!(blame.len(), 1);
-        assert_eq!(blame.iter().count(), 1);
-
-        let hunk = blame.get_index(0).unwrap();
-        assert_eq!(hunk.final_commit_id(), commit);
-        assert_eq!(hunk.final_signature().name(), sig.name());
-        assert_eq!(hunk.final_signature().email(), sig.email());
-        assert_eq!(hunk.final_start_line(), 1);
-        assert_eq!(hunk.path(), Some(Path::new("foo/bar")));
-        assert_eq!(hunk.lines_in_hunk(), 0);
-        assert!(!hunk.is_boundary())
-    });
+    use crate::Repository;
+
+    repo_test!(
+        smoke,
+        (Typical, TypicalWorktree, BareWorktree),
+        |repo: &Repository| {
+            let mut index = repo.index().unwrap();
+
+            let root = repo.path().parent().unwrap();
+            fs::create_dir(&root.join("foo")).unwrap();
+            File::create(&root.join("foo/bar")).unwrap();
+            index.add_path(Path::new("foo/bar")).unwrap();
+
+            let id = index.write_tree().unwrap();
+            let tree = repo.find_tree(id).unwrap();
+            let sig = repo.signature().unwrap();
+            let id = repo.refname_to_id("HEAD").unwrap();
+            let parent = repo.find_commit(id).unwrap();
+            let commit = repo
+                .commit(Some("HEAD"), &sig, &sig, "commit", &tree, &[&parent])
+                .unwrap();
+
+            let blame = repo.blame_file(Path::new("foo/bar"), None).unwrap();
+
+            assert_eq!(blame.len(), 1);
+            assert_eq!(blame.iter().count(), 1);
+
+            let hunk = blame.get_index(0).unwrap();
+            assert_eq!(hunk.final_commit_id(), commit);
+            assert_eq!(hunk.final_signature().name(), sig.name());
+            assert_eq!(hunk.final_signature().email(), sig.email());
+            assert_eq!(hunk.final_start_line(), 1);
+            assert_eq!(hunk.path(), Some(Path::new("foo/bar")));
+            assert_eq!(hunk.lines_in_hunk(), 0);
+            assert!(!hunk.is_boundary())
+        }
+    );
 }

src/branch.rs

@@ -153,7 +153,7 @@ impl<'repo> Drop for Branches<'repo> {
 mod tests {
     use crate::BranchType;
 
-    repo_test!(smoke, Typical, TypicalWorktree, BareWorktree {
+    repo_test!(smoke, (Typical, TypicalWorktree, BareWorktree), |_| {
         let (_td, repo) = crate::test::repo_init();
         let head = repo.head().unwrap();
         let target = head.target().unwrap();

src/test.rs

@@ -19,13 +19,13 @@ macro_rules! t {
 
 // `repo_test! will
 macro_rules! repo_test {
-    ($test_name:ident, $($repo_type:ident),+ $test_body:block) => {
+    ($test_name:ident, ($($repo_type:ident),+), $test_body:expr) => {
         paste::item! {
             $(#[test]
             fn [<$test_name _ $repo_type:snake>]() {
                 #[allow(unused_variables)]
                 let (td, repo) = $crate::test::repo_init2($crate::test::RepoType::$repo_type);
-                $test_body
+                ($test_body)(&repo);
             })+
         }
     }

src/worktree.rs

@@ -260,11 +260,12 @@ impl Drop for Worktree {
 
 #[cfg(test)]
 mod tests {
+    use crate::Repository;
     use crate::WorktreeAddOptions;
     use crate::WorktreeLockStatus;
     use tempfile::TempDir;
 
-    repo_test!(smoke_add_no_ref, Typical, Bare {
+    repo_test!(smoke_add_no_ref, (Typical, Bare), |repo: &Repository| {
         let wtdir = TempDir::new().unwrap();
         let wt_path = wtdir.path().join("tree-no-ref-dir");
         let opts = WorktreeAddOptions::new(None);
@@ -279,7 +280,7 @@ mod tests {
         assert_eq!(status, WorktreeLockStatus::Unlocked);
     });
 
-    repo_test!(smoke_add_locked, Typical, Bare {
+    repo_test!(smoke_add_locked, (Typical, Bare), |repo: &Repository| {
         let wtdir = TempDir::new().unwrap();
         let wt_path = wtdir.path().join("locked-tree");
         let mut opts = WorktreeAddOptions::new(None);
@@ -302,18 +303,22 @@ mod tests {
         );
     });
 
-    repo_test!(smoke_add_from_branch, Typical, Bare {
-        let (wt_top, branch) = crate::test::worktrees_env_init(&repo);
-        let wt_path = wt_top.path().join("test");
-        let opts = WorktreeAddOptions::new(Some(branch.into_reference()));
-
-        let wt = repo.worktree_add("test-worktree", &wt_path, &opts).unwrap();
-        assert_eq!(wt.name(), Some("test-worktree"));
-        assert_eq!(
-            wt.path().canonicalize().unwrap(),
-            wt_path.canonicalize().unwrap()
-        );
-        let status = wt.is_locked().unwrap();
-        assert_eq!(status, WorktreeLockStatus::Unlocked);
-    });
+    repo_test!(
+        smoke_add_from_branch,
+        (Typical, Bare),
+        |repo: &Repository| {
+            let (wt_top, branch) = crate::test::worktrees_env_init(&repo);
+            let wt_path = wt_top.path().join("test");
+            let opts = WorktreeAddOptions::new(Some(branch.into_reference()));
+
+            let wt = repo.worktree_add("test-worktree", &wt_path, &opts).unwrap();
+            assert_eq!(wt.name(), Some("test-worktree"));
+            assert_eq!(
+                wt.path().canonicalize().unwrap(),
+                wt_path.canonicalize().unwrap()
+            );
+            let status = wt.is_locked().unwrap();
+            assert_eq!(status, WorktreeLockStatus::Unlocked);
+        }
+    );
 }