Move LinearMemory test from vm::Memory to Tunables

lib/api/src/sys/tunables.rs

@@ -134,6 +134,8 @@ impl Tunables for BaseTunables {
 
 #[cfg(test)]
 mod tests {
+    use crate::sys::tunables;
+
     use super::*;
 
     #[test]
@@ -174,4 +176,81 @@ mod tests {
             s => panic!("Unexpected memory style: {:?}", s),
         }
     }
+
+    use std::cell::UnsafeCell;
+    use std::ptr::read_unaligned;
+    use std::ptr::write_unaligned;
+    use std::ptr::NonNull;
+    use wasmer_types::{MemoryError, MemoryStyle, MemoryType, Pages, WASM_PAGE_SIZE};
+    use wasmer_vm::{LinearMemory, MaybeInstanceOwned};
+
+    #[derive(Debug)]
+    struct VMTinyMemory {
+        mem: [u8; WASM_PAGE_SIZE],
+    }
+
+    unsafe impl Send for VMTinyMemory {}
+    unsafe impl Sync for VMTinyMemory {}
+
+    impl VMTinyMemory {
+        pub fn new() -> Result<Self, MemoryError> {
+            Ok(VMTinyMemory {
+                mem: [0; WASM_PAGE_SIZE],
+            })
+        }
+    }
+
+    impl LinearMemory for VMTinyMemory {
+        fn ty(&self) -> MemoryType {
+            MemoryType {
+                minimum: Pages::from(1u32),
+                maximum: Some(Pages::from(1u32)),
+                shared: false,
+            }
+        }
+        fn size(&self) -> Pages {
+            Pages::from(1u32)
+        }
+        fn style(&self) -> MemoryStyle {
+            MemoryStyle::Static {
+                bound: Pages::from(1u32),
+                offset_guard_size: 0,
+            }
+        }
+        fn grow(&mut self, delta: Pages) -> Result<Pages, MemoryError> {
+            Err(MemoryError::CouldNotGrow {
+                current: Pages::from(1u32),
+                attempted_delta: delta,
+            })
+        }
+        fn vmmemory(&self) -> NonNull<VMMemoryDefinition> {
+            MaybeInstanceOwned::Host(Box::new(UnsafeCell::new(VMMemoryDefinition {
+                base: self.mem.as_ptr() as _,
+                current_length: WASM_PAGE_SIZE,
+            })))
+            .as_ptr()
+        }
+        fn try_clone(&self) -> Option<Box<dyn LinearMemory + 'static>> {
+            None
+        }
+    }
+
+    impl From<VMTinyMemory> for wasmer_vm::VMMemory {
+        fn from(mem: VMTinyMemory) -> Self {
+            Self(Box::new(mem))
+        }
+    }
+
+    #[test]
+    fn check_linearmemory() {
+        let mut memory = VMTinyMemory::new().unwrap();
+        assert!(memory.grow(Pages::from(2u32)).is_err());
+        assert_eq!(memory.size(), Pages::from(1u32));
+        let target = Target::default();
+        let tunables = BaseTunables::for_target(&target);
+        let vmmemory =
+            unsafe { tunables.create_vm_memory(&memory.ty(), &memory.style(), memory.vmmemory()) };
+        let vmmemory = vmmemory.unwrap();
+        assert_eq!(vmmemory.size(), Pages::from(1u32));
+    }
 }