Tests: use macro to initialize memory

Author: xarantolus

README.md

@@ -241,17 +241,17 @@ ax_test![add_al_byte_ptr_rbx_cf;
     0x2, 0x3;
     // A setup function that is called before the instruction is executed:
     |a: &mut Axecutor| {
-        write_reg_value!(b; a; AL; 0x20);
-
+        write_reg_value!(b; a; AL; 0x8);
         // This sets up a memory area with a size of one byte, containing 0xff
+        init_mem_value!(b; a; 0x1000; 0xff); // -1
+        // RBX points to that memory area
         write_reg_value!(q; a; RBX; 0x1000);
-        a.mem_init_zero(0x1000, 1).unwrap();
-        a.mem_write_8(0x1000, 0xff).unwrap();
     };
     // This function is called after the instruction ran and checks the result:
     |a: Axecutor| {
-        assert_reg_value!(b; a; AL; 0x1f);
+        assert_reg_value!(b; a; AL; 0x7);
         // Also make sure the source operand is unchanged
+        assert_reg_value!(q; a; RBX; 0x1000);
         assert_mem_value!(b; a; 0x1000; 0xff);
     };
     // On the left side of `;` are the flags that must be set after the instruction ran,

generate.py

@@ -198,7 +198,7 @@ def generate_mnemonic_text(instruction_codes: list[Instruction], mnemonic: str):
     #[cfg(test)]
 mod tests {
     use crate::helpers::tests::{{
-        assert_mem_value, assert_reg_value, ax_test, jmp_test, test_async, write_reg_value, write_flags,
+        assert_mem_value, assert_reg_value, ax_test, jmp_test, test_async, write_reg_value, write_flags, init_mem_value,
     }};
     use crate::{axecutor::Axecutor, state::flags::*};
     use iced_x86::Register::*;

src/helpers/operand.rs

@@ -357,8 +357,7 @@ mod tests {
             Immediate { data: 1, size: 1 },
         ];
         |a: &mut Axecutor| {
-            use iced_x86::Register::*;
-            a.reg_write_64(RSP.into(), 0x1000).unwrap();
+            write_reg_value!(q; a; RSP; 0x1000);
         };
         vec![
             0x1000
@@ -379,8 +378,7 @@ mod tests {
             Immediate { data: 1, size: 4 },
         ];
         |a: &mut Axecutor| {
-            use iced_x86::Register::*;
-            a.reg_write_64(RSP.into(), 0x1000).unwrap();
+            write_reg_value!(q; a; RSP; 0x1000);
         };
         vec![
             0x1000
@@ -401,8 +399,7 @@ mod tests {
             Register(Register::R15D.into()),
         ];
         |a: &mut Axecutor| {
-            use iced_x86::Register::*;
-            a.reg_write_64(RSP.into(), 0x1000).unwrap();
+            write_reg_value!(q; a; RSP; 0x1000);
         };
         vec![
             0x1001
@@ -424,8 +421,7 @@ mod tests {
             Register(Register::R15D.into()),
         ];
         |a: &mut Axecutor| {
-            use iced_x86::Register::*;
-            a.reg_write_64(RSP.into(), 0x1000).unwrap();
+            write_reg_value!(q; a; RSP; 0x1000);
         };
         vec![
             0x0fff
@@ -446,9 +442,8 @@ mod tests {
             Immediate { data: 1, size: 8 },
         ];
         |a: &mut Axecutor| {
-            use iced_x86::Register::*;
-            a.reg_write_64(R11.into(), 0x8001).unwrap();
-            a.reg_write_64(RCX.into(), 5).unwrap();
+            write_reg_value!(q; a; R11; 0x8001);
+            write_reg_value!(q; a; RCX; 5);
         };
         vec![
             0x8015

src/helpers/tests.rs

@@ -287,6 +287,53 @@ macro_rules! write_reg_value {
 #[cfg(test)]
 pub(crate) use write_reg_value;
 
+#[cfg(test)]
+macro_rules! init_mem_value {
+    (b; $axecutor:expr; $addr:expr; $value:expr) => {
+        $axecutor
+            .mem_init_zero($addr, 1)
+            .expect("could not initialize 8-bit memory");
+        $axecutor
+            .mem_write_8($addr, $value as u64)
+            .expect("could not write 8-bit memory");
+    };
+    (w; $axecutor:expr; $addr:expr; $value:expr) => {
+        $axecutor
+            .mem_init_zero($addr, 2)
+            .expect("could not initialize 16-bit memory");
+        $axecutor
+            .mem_write_16($addr, $value as u64)
+            .expect("could not write 16-bit memory");
+    };
+    (d; $axecutor:expr; $addr:expr; $value:expr) => {
+        $axecutor
+            .mem_init_zero($addr, 4)
+            .expect("could not initialize 32-bit memory");
+        $axecutor
+            .mem_write_32($addr, $value as u64)
+            .expect("could not write 32-bit memory");
+    };
+    (q; $axecutor:expr; $addr:expr; $value:expr) => {
+        $axecutor
+            .mem_init_zero($addr, 8)
+            .expect("could not initialize 64-bit memory");
+        $axecutor
+            .mem_write_64($addr, $value as u64)
+            .expect("could not write 64-bit memory");
+    };
+    (x; $axecutor:expr; $addr:expr; $value:expr) => {
+        $axecutor
+            .mem_init_zero($addr, 16)
+            .expect("could not initialize 128-bit memory");
+        $axecutor
+            .mem_write_128($addr, $value as u128)
+            .expect("could not write 128-bit memory");
+    };
+}
+
+#[cfg(test)]
+pub(crate) use init_mem_value;
+
 #[cfg(test)]
 macro_rules! write_flags {
     ($axecutor:expr; $flags:expr) => {