add test for calls.rs and vm.rs

Author: colmazia

packages/vm/src/calls.rs

@@ -66,7 +66,7 @@ mod test {
 
     impl vm::Env for MockEnv {
         fn get_span_size(&self) -> i64 {
-            30000
+            300
         }
         fn get_calldata(&self) -> Result<Vec<u8>, Error> {
             Ok(vec![1])
@@ -143,7 +143,7 @@ mod test {
         let code = compile(&wasm).unwrap();
         let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
         let env = MockEnv {};
-        let gas_used = run(&mut cache, &code, 4294967290, true, env).unwrap();
+        let gas_used = run(&mut cache, &code, u64::MAX, true, env).unwrap();
         assert_eq!(gas_used, 800013 as u64);
     }
 
@@ -181,7 +181,37 @@ mod test {
         let code = compile(&wasm).unwrap();
         let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
         let env = MockEnv {};
-        let gas_used = run(&mut cache, &code, 4294967290, true, env).unwrap();
-        assert_eq!(gas_used, 830018 as u64);
+        let gas_used = run(&mut cache, &code, u64::MAX, true, env).unwrap();
+        assert_eq!(gas_used, 800318 as u64);
+    }
+
+    #[test]
+    fn test_out_of_gas() {
+        let wasm = wat2wasm(
+            r#"(module
+            (type (func (param i64 i64 i64 i64) (result)))
+            (func
+              (local $idx i32)
+              (local.set $idx (i32.const 0))
+              (block
+                  (loop
+                    (local.set $idx (local.get $idx) (i32.const 1) (i32.add) )
+                    (br_if 0 (i32.lt_u (local.get $idx) (i32.const 100000)))
+                  )
+                )
+            )
+            (func (;"execute": Resolves with result "beeb";)
+              )
+            (memory 17)
+            (data (i32.const 1048576) "beeb") (;str = "beeb";)
+            (export "prepare" (func 0))
+            (export "execute" (func 1)))
+          "#,
+        );
+        let code = compile(&wasm).unwrap();
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let env = MockEnv {};
+        let out_of_gas_err = run(&mut cache, &code, 0, true, env).unwrap_err();
+        assert_eq!(out_of_gas_err, Error::OutOfGasError);
     }
 }

packages/vm/src/compile.rs

@@ -287,14 +287,14 @@ mod test {
     fn test_check_wasm_imports() {
         let wasm = wat2wasm(
             r#"(module
-                (type (func (param i64 i64 i32 i64) (result i64)))
+                (type (func (param i64 i64 i64 i64) (result i64)))
                 (import "env" "beeb" (func (type 0))))"#,
         );
         let module = get_module_from_wasm(&wasm);
         assert_eq!(check_wasm_imports(&module), Err(Error::InvalidImportsError));
         let wasm = wat2wasm(
             r#"(module
-                (type (func (param i64 i64 i32 i64) (result i64)))
+                (type (func (param i64 i64 i64 i64) (result i64)))
                 (import "env" "ask_external_data" (func  (type 0))))"#,
         );
         let module = get_module_from_wasm(&wasm);
@@ -309,6 +309,12 @@ mod test {
         );
         let module = get_module_from_wasm(&wasm);
         assert_eq!(check_wasm_exports(&module), Err(Error::InvalidExportsError));
+        let wasm = wat2wasm(
+            r#"(module
+                (func $prepare (export "prepare")))"#,
+        );
+        let module = get_module_from_wasm(&wasm);
+        assert_eq!(check_wasm_exports(&module), Err(Error::InvalidExportsError));
         let wasm = wat2wasm(
             r#"(module
                 (func $execute (export "execute"))

packages/vm/src/store.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
-use wasmer::{Singlepass, Store, Universal, wasmparser::Operator, CompilerConfig};
+use wasmer::wasmparser::Operator;
+use wasmer::{CompilerConfig, Singlepass, Store, Universal};
 use wasmer_middlewares::Metering;
 
 fn cost(_operator: &Operator) -> u64 {

packages/vm/src/vm.rs

@@ -175,3 +175,131 @@ where
         }
     }
 }
+
+#[cfg(test)]
+mod test {
+    use std::{
+        io::{Read, Write},
+        process::Command,
+    };
+
+    use tempfile::NamedTempFile;
+    use wasmer::{imports, Singlepass, Store, Universal};
+
+    use crate::{
+        cache::{Cache, CacheOptions},
+        store::make_store,
+    };
+
+    use super::*;
+
+    pub struct MockEnv {}
+
+    impl Env for MockEnv {
+        fn get_span_size(&self) -> i64 {
+            300
+        }
+        fn get_calldata(&self) -> Result<Vec<u8>, Error> {
+            Ok(vec![1])
+        }
+        fn set_return_data(&self, _: &[u8]) -> Result<(), Error> {
+            Ok(())
+        }
+        fn get_ask_count(&self) -> i64 {
+            10
+        }
+        fn get_min_count(&self) -> i64 {
+            8
+        }
+        fn get_prepare_time(&self) -> i64 {
+            100_000
+        }
+        fn get_execute_time(&self) -> Result<i64, Error> {
+            Ok(100_000)
+        }
+        fn get_ans_count(&self) -> Result<i64, Error> {
+            Ok(8)
+        }
+        fn ask_external_data(&self, _: i64, _: i64, _: &[u8]) -> Result<(), Error> {
+            Ok(())
+        }
+        fn get_external_data_status(&self, _: i64, _: i64) -> Result<i64, Error> {
+            Ok(1)
+        }
+        fn get_external_data(&self, _: i64, _: i64) -> Result<Vec<u8>, Error> {
+            Ok(vec![1])
+        }
+    }
+
+    fn wat2wasm(wat: impl AsRef<[u8]>) -> Vec<u8> {
+        let mut input_file = NamedTempFile::new().unwrap();
+        let mut output_file = NamedTempFile::new().unwrap();
+        input_file.write_all(wat.as_ref()).unwrap();
+        Command::new("wat2wasm")
+            .args(&[
+                input_file.path().to_str().unwrap(),
+                "-o",
+                output_file.path().to_str().unwrap(),
+            ])
+            .output()
+            .unwrap();
+        let mut wasm = Vec::new();
+        output_file.read_to_end(&mut wasm).unwrap();
+        wasm
+    }
+
+    #[test]
+    fn test_env_vm() {
+        let env = Environment::new(MockEnv {});
+        assert_eq!(300, env.with_vm(|vm| vm.env.get_span_size()));
+        assert_eq!(300, env.with_mut_vm(|vm| vm.env.get_span_size()));
+    }
+
+    #[test]
+    fn test_env_wasmer_instance() {
+        let env = Environment::new(MockEnv {});
+        assert_eq!(
+            Error::UninitializedContextData,
+            env.with_wasmer_instance(|_| { Ok(()) }).unwrap_err()
+        );
+
+        let wasm = wat2wasm(
+            r#"(module
+                (func $execute (export "execute"))
+                (func $prepare (export "prepare"))
+              )"#,
+        );
+        let compiler = Singlepass::new();
+        let store = Store::new(&Universal::new(compiler).engine());
+        let import_object = imports! {};
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let instance = cache.get_instance(&wasm, &store, &import_object).unwrap();
+        env.set_wasmer_instance(Some(NonNull::from(&instance)));
+        assert_eq!(Ok(()), env.with_wasmer_instance(|_| { Ok(()) }));
+    }
+
+    #[test]
+    fn test_env_gas() {
+        let env = Environment::new(MockEnv {});
+        let wasm = wat2wasm(
+            r#"(module
+                (func $execute (export "execute"))
+                (func $prepare (export "prepare"))
+              )"#,
+        );
+        let store = make_store();
+        let import_object = imports! {};
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let instance = cache.get_instance(&wasm, &store, &import_object).unwrap();
+        env.set_wasmer_instance(Some(NonNull::from(&instance)));
+
+        assert_eq!(0, env.get_gas_left());
+
+        env.set_gas_left(10);
+        assert_eq!(10, env.get_gas_left());
+
+        assert_eq!(Error::OutOfGasError, env.decrease_gas_left(11).unwrap_err());
+        assert_eq!(Ok(()), env.decrease_gas_left(3));
+        assert_eq!(7, env.get_gas_left());
+    }
+}