diff --git a/src/arch/x86_64/test/nasm.rs b/src/arch/x86_64/test/nasm.rs
index 49456bc..3d57725 100644
--- a/src/arch/x86_64/test/nasm.rs
+++ b/src/arch/x86_64/test/nasm.rs
@@ -34,15 +34,16 @@ const WIDTHS: &[Width] = &[Width::B8, Width::B16, Width::B32, Width::B64];
 
 #[test]
 fn mov() {
+    let c = &mut Code::default();
     for &r1 in Reg::IMPORTANT {
         for &r2 in Reg::IMPORTANT {
-            eq!(format!("mov {r1}, {r2}"), mov(r1, r2));
+            eq(c, format!("mov {r1}, {r2}"), |c| c.mov(r1, r2));
         }
     }
 
     for &r1 in Reg::IMPORTANT {
         for &imm in IMMS {
-            eq!(format!("mov {r1}, {imm}"), mov(r1, imm));
+            eq(c, format!("mov {r1}, {imm}"), |c| c.mov(r1, imm));
         }
     }
 
@@ -51,47 +52,42 @@ fn mov() {
             for &imm in IMMS {
                 for &width in WIDTHS {
                     let mem = mem(reg, disp, width);
-                    eq!(format!("mov {mem}, {imm}"), mov(mem, imm));
+                    eq(c, format!("mov {mem}, {imm}"), |c| c.mov(mem, imm));
                 }
             }
         }
     }
 }
 
-fn u_to_i(u: u64) -> i64 {
-    match u {
-        0..0x100 => u as i8 as i64,
-        0x100..0x10000 => u as i16 as i64,
-        0x10000..0x100000000 => u as i32 as i64,
-        0x100000000.. => u as i64,
-    }
-}
-
-macro_rules! eq {
-    ($asm:expr, $instr:ident $args:tt $(,)?) => {
-        let asm = $asm;
-        let expected = nasm(asm.as_ref());
-        let mut code = Code::default();
-        let res = code.$instr $args;
-        match (expected, res) {
-            (Ok(expected), Err(e)) => {
-                panic!("{asm}: failed to compile: {}\nexpected: {expected:x?}", e.msg);
-            }
-            (Err(e), Ok(_)) => {
-                let res = &code.bytes[..];
-                panic!("{asm}: should not have compiled:\n{e}\ngot: {res:x?}");
-            }
-            (Err(_), Err(_)) => (),
-            (Ok(expected), Ok(_)) => {
-                let res = &code.bytes[..];
-                if expected != res {
-                    panic!("{asm}: expected {expected:x?}, got {res:x?}")
-                }
+fn eq(
+    code: &mut Code,
+    asm: impl AsRef<str>,
+    instr: impl FnOnce(&mut Code) -> Result<(), CompilerMsg>,
+) {
+    let asm = asm.as_ref();
+    let expected = nasm(asm);
+    let res = instr(code);
+    match (expected, res) {
+        (Ok(expected), Err(e)) => {
+            panic!(
+                "{asm}: failed to compile: {}\nexpected: {expected:x?}",
+                e.msg
+            );
+        }
+        (Err(e), Ok(_)) => {
+            let res = &code.bytes[..];
+            panic!("{asm}: should not have compiled:\n{e}\ngot: {res:x?}");
+        }
+        (Err(_), Err(_)) => (),
+        (Ok(expected), Ok(_)) => {
+            let res = &code.bytes[..];
+            if expected != res {
+                panic!("{asm}: expected {expected:x?}, got {res:x?}")
             }
         }
-    };
+    }
+    code.bytes.clear();
 }
-use eq;
 
 fn nasm(input: &str) -> Result<Vec<u8>, String> {
     let fin = "/tmp/69420nasm_in.asm";