finish factoring tests (#17)

* atoms in one test unit

* factor out pointers test

* factor structs into separate test unit

* factor out arrays, flags

* finally, separate into strings and ints

tests/structs.rs

@@ -0,0 +1,202 @@
+use proptest::prelude::*;
+use wiggle_runtime::GuestError;
+use wiggle_test::{impl_errno, HostMemory, MemArea, WasiCtx};
+
+wiggle_generate::from_witx!({
+    witx: ["tests/structs.witx"],
+    ctx: WasiCtx,
+});
+
+impl_errno!(types::Errno);
+
+impl structs::Structs for WasiCtx {
+    fn sum_of_pair(&mut self, an_pair: &types::PairInts) -> Result<i64, types::Errno> {
+        Ok(an_pair.first as i64 + an_pair.second as i64)
+    }
+
+    fn sum_of_pair_of_ptrs(&mut self, an_pair: &types::PairIntPtrs) -> Result<i64, types::Errno> {
+        let first = *an_pair
+            .first
+            .as_ref()
+            .expect("dereferencing GuestPtr should succeed");
+        let second = *an_pair
+            .second
+            .as_ref()
+            .expect("dereferncing GuestPtr should succeed");
+        Ok(first as i64 + second as i64)
+    }
+}
+
+#[derive(Debug)]
+struct SumOfPairExercise {
+    pub input: types::PairInts,
+    pub input_loc: MemArea,
+    pub return_loc: MemArea,
+}
+
+impl SumOfPairExercise {
+    pub fn strat() -> BoxedStrategy<Self> {
+        (
+            prop::num::i32::ANY,
+            prop::num::i32::ANY,
+            HostMemory::mem_area_strat(8),
+            HostMemory::mem_area_strat(8),
+        )
+            .prop_map(|(first, second, input_loc, return_loc)| SumOfPairExercise {
+                input: types::PairInts { first, second },
+                input_loc,
+                return_loc,
+            })
+            .prop_filter("non-overlapping pointers", |e| {
+                MemArea::non_overlapping_set(&[&e.input_loc, &e.return_loc])
+            })
+            .boxed()
+    }
+
+    pub fn test(&self) {
+        let mut ctx = WasiCtx::new();
+        let mut host_memory = HostMemory::new();
+        let mut guest_memory = host_memory.guest_memory();
+
+        *guest_memory
+            .ptr_mut(self.input_loc.ptr)
+            .expect("input ptr")
+            .as_ref_mut()
+            .expect("input ref_mut") = self.input.first;
+        *guest_memory
+            .ptr_mut(self.input_loc.ptr + 4)
+            .expect("input ptr")
+            .as_ref_mut()
+            .expect("input ref_mut") = self.input.second;
+        let sum_err = structs::sum_of_pair(
+            &mut ctx,
+            &mut guest_memory,
+            self.input_loc.ptr as i32,
+            self.return_loc.ptr as i32,
+        );
+
+        assert_eq!(sum_err, types::Errno::Ok.into(), "sum errno");
+
+        let return_val: i64 = *guest_memory
+            .ptr(self.return_loc.ptr)
+            .expect("return ptr")
+            .as_ref()
+            .expect("return ref");
+
+        assert_eq!(
+            return_val,
+            self.input.first as i64 + self.input.second as i64,
+            "sum return value"
+        );
+    }
+}
+
+proptest! {
+    #[test]
+    fn sum_of_pair(e in SumOfPairExercise::strat()) {
+        e.test();
+    }
+}
+
+#[derive(Debug)]
+struct SumPairPtrsExercise {
+    input_first: i32,
+    input_second: i32,
+    input_first_loc: MemArea,
+    input_second_loc: MemArea,
+    input_struct_loc: MemArea,
+    return_loc: MemArea,
+}
+
+impl SumPairPtrsExercise {
+    pub fn strat() -> BoxedStrategy<Self> {
+        (
+            prop::num::i32::ANY,
+            prop::num::i32::ANY,
+            HostMemory::mem_area_strat(4),
+            HostMemory::mem_area_strat(4),
+            HostMemory::mem_area_strat(8),
+            HostMemory::mem_area_strat(8),
+        )
+            .prop_map(
+                |(
+                    input_first,
+                    input_second,
+                    input_first_loc,
+                    input_second_loc,
+                    input_struct_loc,
+                    return_loc,
+                )| SumPairPtrsExercise {
+                    input_first,
+                    input_second,
+                    input_first_loc,
+                    input_second_loc,
+                    input_struct_loc,
+                    return_loc,
+                },
+            )
+            .prop_filter("non-overlapping pointers", |e| {
+                MemArea::non_overlapping_set(&[
+                    &e.input_first_loc,
+                    &e.input_second_loc,
+                    &e.input_struct_loc,
+                    &e.return_loc,
+                ])
+            })
+            .boxed()
+    }
+    pub fn test(&self) {
+        let mut ctx = WasiCtx::new();
+        let mut host_memory = HostMemory::new();
+        let mut guest_memory = host_memory.guest_memory();
+
+        *guest_memory
+            .ptr_mut(self.input_first_loc.ptr)
+            .expect("input_first ptr")
+            .as_ref_mut()
+            .expect("input_first ref") = self.input_first;
+        *guest_memory
+            .ptr_mut(self.input_second_loc.ptr)
+            .expect("input_second ptr")
+            .as_ref_mut()
+            .expect("input_second ref") = self.input_second;
+
+        *guest_memory
+            .ptr_mut(self.input_struct_loc.ptr)
+            .expect("input_struct ptr")
+            .as_ref_mut()
+            .expect("input_struct ref") = self.input_first_loc.ptr;
+        *guest_memory
+            .ptr_mut(self.input_struct_loc.ptr + 4)
+            .expect("input_struct ptr")
+            .as_ref_mut()
+            .expect("input_struct ref") = self.input_second_loc.ptr;
+
+        let res = structs::sum_of_pair_of_ptrs(
+            &mut ctx,
+            &mut guest_memory,
+            self.input_struct_loc.ptr as i32,
+            self.return_loc.ptr as i32,
+        );
+
+        assert_eq!(res, types::Errno::Ok.into(), "sum of pair of ptrs errno");
+
+        let doubled: i64 = *guest_memory
+            .ptr(self.return_loc.ptr)
+            .expect("return ptr")
+            .as_ref()
+            .expect("return ref");
+
+        assert_eq!(
+            doubled,
+            (self.input_first as i64) + (self.input_second as i64),
+            "sum of pair of ptrs return val"
+        );
+    }
+}
+proptest! {
+    #[test]
+    fn sum_of_pair_of_ptrs(e in SumPairPtrsExercise::strat()) {
+        e.test()
+    }
+}