fluencelabs/parity-wasm
1
0
Fork 0
mirror of https://github.com/fluencelabs/parity-wasm synced 2025-06-13 23:11:53 +00:00
Code Issues Projects Releases Wiki Activity

Use slices for args in usercode and Cow for invoke

Browse Source
This commit is contained in:
Sergey Pepyakin
2017-12-18 13:21:32 +03:00
parent 460daf8651
commit a1b3064fbf
11 changed files with 267 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
examples/interpret.rs
View File

@ -22,7 +22,7 @@ fn main() {
// - a module declaration // - a module declaration
// - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here // - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here
// This test shows how to implement native module https://github.com/NikVolf/parity-wasm/blob/master/src/interpreter/tests/basics.rs#L197 // This test shows how to implement native module https://github.com/NikVolf/parity-wasm/blob/master/src/interpreter/tests/basics.rs#L197
let main = ModuleInstance::instantiate(&module) let main = ModuleInstance::new(&module)
.run_start(&mut ()) .run_start(&mut ())
.expect("Failed to initialize module"); .expect("Failed to initialize module");
@ -30,5 +30,5 @@ fn main() {
let argument: i32 = args[2].parse().expect("Integer argument required"); let argument: i32 = args[2].parse().expect("Integer argument required");
// "_call" export of function to be executed with an i32 argument and prints the result of execution // "_call" export of function to be executed with an i32 argument and prints the result of execution
println!("Result: {:?}", main.invoke_export("_call", vec![parity_wasm::RuntimeValue::I32(argument)], &mut ())); println!("Result: {:?}", main.invoke_export("_call", &[parity_wasm::RuntimeValue::I32(argument)], &mut ()));
} }

4
examples/invoke.rs
View File

@ -74,9 +74,9 @@ fn main() {
// - a module declaration // - a module declaration
// - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here // - "main" module doesn't import native module(s) this is why we don't need to provide external native modules here
// This test shows how to implement native module https://github.com/NikVolf/parity-wasm/blob/master/src/interpreter/tests/basics.rs#L197 // This test shows how to implement native module https://github.com/NikVolf/parity-wasm/blob/master/src/interpreter/tests/basics.rs#L197
let main = ModuleInstance::instantiate(&module) let main = ModuleInstance::new(&module)
.run_start(&mut ()) .run_start(&mut ())
.expect("Failed to initialize module"); .expect("Failed to initialize module");
println!("Result: {:?}", main.invoke_export(func_name, args, &mut ()).expect("")); println!("Result: {:?}", main.invoke_export(func_name, &args, &mut ()).expect(""));
} }

4
examples/tictactoe.rs
View File

@ -146,7 +146,7 @@ fn instantiate<'a, 'b>(
env: &HostModule<Runtime<'a>>, env: &HostModule<Runtime<'a>>,
runtime: &'b Runtime<'a>, runtime: &'b Runtime<'a>,
) -> Result<Rc<ModuleInstance<Runtime<'a>>>, Error> { ) -> Result<Rc<ModuleInstance<Runtime<'a>>>, Error> {
let instance = ModuleInstance::instantiate(module) let instance = ModuleInstance::new(module)
.with_import("env", &*env) .with_import("env", &*env)
.run_start(runtime)?; .run_start(runtime)?;
@ -205,7 +205,7 @@ fn play<'a>(
player: turn_of, player: turn_of,
game: game, game: game,
}; };
let _ = instance.invoke_export("mk_turn", vec![], &runtime)?; let _ = instance.invoke_export("mk_turn", &[], &runtime)?;
match game.game_result() { match game.game_result() {
Some(game_result) => break game_result, Some(game_result) => break game_result,

2
src/common/stack.rs
View File

@ -21,7 +21,7 @@ pub struct StackWithLimit<T> where T: Clone {
} }
impl<T> StackWithLimit<T> where T: Clone { impl<T> StackWithLimit<T> where T: Clone {
pub fn with_data(data: Vec<T>, limit: usize) -> Self { pub fn with_data<D: IntoIterator<Item=T>>(data: D, limit: usize) -> Self {
StackWithLimit { StackWithLimit {
values: data.into_iter().collect(), values: data.into_iter().collect(),
limit: limit limit: limit

15
src/interpreter/func.rs
View File

@ -1,6 +1,7 @@
use std::rc::Rc; use std::rc::Rc;
use std::fmt; use std::fmt;
use std::collections::HashMap; use std::collections::HashMap;
use std::borrow::Cow;
use elements::{FunctionType, Opcodes, Local}; use elements::{FunctionType, Opcodes, Local};
use interpreter::{Error, ModuleInstance}; use interpreter::{Error, ModuleInstance};
use interpreter::runner::{prepare_function_args, FunctionContext, Interpreter}; use interpreter::runner::{prepare_function_args, FunctionContext, Interpreter};
@ -83,18 +84,18 @@ impl<St> FuncInstance<St> {
pub fn invoke( pub fn invoke(
func: Rc<FuncInstance<St>>, func: Rc<FuncInstance<St>>,
args: Vec<RuntimeValue>, args: Cow<[RuntimeValue]>,
state: &St, state: &St,
) -> Result<Option<RuntimeValue>, Error> { ) -> Result<Option<RuntimeValue>, Error> {
enum InvokeKind<St> { enum InvokeKind<'a, St> {
Internal(FunctionContext<St>), Internal(FunctionContext<St>),
Host(Rc<HostFunc<St>>, Vec<RuntimeValue>), Host(Rc<HostFunc<St>>, &'a [RuntimeValue]),
} }
let result = match *func { let result = match *func {
FuncInstance::Internal { ref func_type, .. } => { FuncInstance::Internal { ref func_type, .. } => {
let mut args = StackWithLimit::with_data(args, DEFAULT_VALUE_STACK_LIMIT); let mut stack = StackWithLimit::with_data(args.into_iter().cloned(), DEFAULT_VALUE_STACK_LIMIT);
let args = prepare_function_args(func_type, &mut args)?; let args = prepare_function_args(func_type, &mut stack)?;
let context = FunctionContext::new( let context = FunctionContext::new(
Rc::clone(&func), Rc::clone(&func),
DEFAULT_VALUE_STACK_LIMIT, DEFAULT_VALUE_STACK_LIMIT,
@ -105,7 +106,7 @@ impl<St> FuncInstance<St> {
InvokeKind::Internal(context) InvokeKind::Internal(context)
} }
FuncInstance::Host { ref host_func, .. } => { FuncInstance::Host { ref host_func, .. } => {
InvokeKind::Host(Rc::clone(host_func), args) InvokeKind::Host(Rc::clone(host_func), &*args)
} }
}; };
@ -114,7 +115,7 @@ impl<St> FuncInstance<St> {
let mut interpreter = Interpreter::new(state); let mut interpreter = Interpreter::new(state);
interpreter.run_function(ctx) interpreter.run_function(ctx)
} }
InvokeKind::Host(host_func, args) => host_func(state, &args), InvokeKind::Host(host_func, args) => host_func(state, args),
} }
} }
} }

11
src/interpreter/module.rs
View File

@ -2,6 +2,7 @@ use std::rc::Rc;
use std::cell::RefCell; use std::cell::RefCell;
use std::fmt; use std::fmt;
use std::collections::HashMap; use std::collections::HashMap;
use std::borrow::Cow;
use elements::{External, FunctionType, GlobalType, InitExpr, Internal, MemoryType, Module, use elements::{External, FunctionType, GlobalType, InitExpr, Internal, MemoryType, Module,
Opcode, ResizableLimits, TableType, Type}; Opcode, ResizableLimits, TableType, Type};
use interpreter::{Error, MemoryInstance, RuntimeValue, TableInstance}; use interpreter::{Error, MemoryInstance, RuntimeValue, TableInstance};
@ -402,7 +403,7 @@ impl<St> ModuleInstance<St> {
pub fn invoke_index( pub fn invoke_index(
&self, &self,
func_idx: u32, func_idx: u32,
args: Vec<RuntimeValue>, args: &[RuntimeValue],
state: &St, state: &St,
) -> Result<Option<RuntimeValue>, Error> { ) -> Result<Option<RuntimeValue>, Error> {
let func_instance = self.func_by_index(func_idx).ok_or_else(|| { let func_instance = self.func_by_index(func_idx).ok_or_else(|| {
@ -411,13 +412,13 @@ impl<St> ModuleInstance<St> {
func_idx func_idx
)) ))
})?; })?;
FuncInstance::invoke(func_instance, args, state) FuncInstance::invoke(func_instance, Cow::Borrowed(args), state)
} }
pub fn invoke_export( pub fn invoke_export(
&self, &self,
func_name: &str, func_name: &str,
args: Vec<RuntimeValue>, args: &[RuntimeValue],
state: &St, state: &St,
) -> Result<Option<RuntimeValue>, Error> { ) -> Result<Option<RuntimeValue>, Error> {
let extern_val = self.export_by_name(func_name).ok_or_else(|| { let extern_val = self.export_by_name(func_name).ok_or_else(|| {
@ -435,7 +436,7 @@ impl<St> ModuleInstance<St> {
} }
}; };
FuncInstance::invoke(Rc::clone(&func_instance), args, state) FuncInstance::invoke(Rc::clone(&func_instance), Cow::Borrowed(args), state)
} }
} }
@ -476,7 +477,7 @@ impl<'a, St: 'a> InstantiationBuilder<'a, St> {
let start_func = instance let start_func = instance
.func_by_index(start_fn_idx) .func_by_index(start_fn_idx)
.expect("Due to validation start function should exists"); .expect("Due to validation start function should exists");
FuncInstance::invoke(start_func, vec![], state)?; FuncInstance::invoke(start_func, Cow::Borrowed(&[]), state)?;
} }
Ok(instance) Ok(instance)
} }

9
src/interpreter/program.rs
View File

@ -1,5 +1,6 @@
use std::rc::Rc; use std::rc::Rc;
use std::collections::HashMap; use std::collections::HashMap;
use std::borrow::Cow;
use elements::Module; use elements::Module;
use interpreter::Error; use interpreter::Error;
use interpreter::module::ModuleInstance; use interpreter::module::ModuleInstance;
@ -72,7 +73,7 @@ impl<St> ProgramInstance<St> {
&mut self, &mut self,
module_name: &str, module_name: &str,
func_name: &str, func_name: &str,
args: Vec<RuntimeValue>, args: &[RuntimeValue],
state: &St, state: &St,
) -> Result<Option<RuntimeValue>, Error> { ) -> Result<Option<RuntimeValue>, Error> {
let module_instance = self.modules.get(module_name).ok_or_else(|| { let module_instance = self.modules.get(module_name).ok_or_else(|| {
@ -85,7 +86,7 @@ impl<St> ProgramInstance<St> {
&mut self, &mut self,
module_name: &str, module_name: &str,
func_idx: u32, func_idx: u32,
args: Vec<RuntimeValue>, args: &[RuntimeValue],
state: &St, state: &St,
) -> Result<Option<RuntimeValue>, Error> { ) -> Result<Option<RuntimeValue>, Error> {
let module_instance = self.modules.get(module_name).cloned().ok_or_else(|| { let module_instance = self.modules.get(module_name).cloned().ok_or_else(|| {
@ -97,10 +98,10 @@ impl<St> ProgramInstance<St> {
pub fn invoke_func( pub fn invoke_func(
&mut self, &mut self,
func_instance: Rc<FuncInstance<St>>, func_instance: Rc<FuncInstance<St>>,
args: Vec<RuntimeValue>, args: &[RuntimeValue],
state: &St, state: &St,
) -> Result<Option<RuntimeValue>, Error> { ) -> Result<Option<RuntimeValue>, Error> {
FuncInstance::invoke(Rc::clone(&func_instance), args, state) FuncInstance::invoke(Rc::clone(&func_instance), Cow::Borrowed(args), state)
} }
pub fn resolver(&self, name: &str) -> Option<&ImportResolver<St>> { pub fn resolver(&self, name: &str) -> Option<&ImportResolver<St>> {

2
src/interpreter/runner.rs
View File

@ -105,7 +105,7 @@ impl<'a, St: 'a> Interpreter<'a, St> {
}, },
FuncInstance::Host { ref func_type, .. } => { FuncInstance::Host { ref func_type, .. } => {
let args = prepare_function_args(func_type, &mut function_context.value_stack)?; let args = prepare_function_args(func_type, &mut function_context.value_stack)?;
let return_val = FuncInstance::invoke(Rc::clone(&nested_func), args, self.state)?; let return_val = FuncInstance::invoke(Rc::clone(&nested_func), args.into(), self.state)?;
if let Some(return_val) = return_val { if let Some(return_val) = return_val {
function_context.value_stack_mut().push(return_val)?; function_context.value_stack_mut().push(return_val)?;
} }

20
src/interpreter/tests/basics.rs
View File

@ -45,8 +45,8 @@ fn import_function() {
.assert_no_start() .assert_no_start()
.unwrap(); .unwrap();
assert_eq!(external_module.invoke_index(0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(3)); assert_eq!(external_module.invoke_index(0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(3));
assert_eq!(main_module.invoke_index(1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(10)); assert_eq!(main_module.invoke_index(1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(10));
} }
#[test] #[test]
@ -99,8 +99,8 @@ fn global_get_set() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(50)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(50));
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(58)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(58));
} }
// custom user error // custom user error
@ -192,19 +192,19 @@ fn native_env_function() {
program.add_module("main", module, &mut state).unwrap(); program.add_module("main", module, &mut state).unwrap();
{ {
assert_eq!( assert_eq!(
program.invoke_index("main", 2, vec![RuntimeValue::I32(7), RuntimeValue::I32(0)], &mut state) program.invoke_index("main", 2, &[RuntimeValue::I32(7), RuntimeValue::I32(0)], &mut state)
.unwrap() .unwrap()
.unwrap(), .unwrap(),
RuntimeValue::I32(7) RuntimeValue::I32(7)
); );
assert_eq!( assert_eq!(
program.invoke_index("main", 2, vec![RuntimeValue::I32(50), RuntimeValue::I32(0)], &mut state) program.invoke_index("main", 2, &[RuntimeValue::I32(50), RuntimeValue::I32(0)], &mut state)
.unwrap() .unwrap()
.unwrap(), .unwrap(),
RuntimeValue::I32(57) RuntimeValue::I32(57)
); );
assert_eq!( assert_eq!(
program.invoke_index("main", 3, vec![RuntimeValue::I32(15), RuntimeValue::I32(0)], &mut state) program.invoke_index("main", 3, &[RuntimeValue::I32(15), RuntimeValue::I32(0)], &mut state)
.unwrap() .unwrap()
.unwrap(), .unwrap(),
RuntimeValue::I32(42) RuntimeValue::I32(42)
@ -235,7 +235,7 @@ fn native_env_global() {
.build() .build()
.build(); .build();
program.add_module("main", module, &State)?; program.add_module("main", module, &State)?;
program.invoke_index("main", 0, vec![], &State) program.invoke_index("main", 0, &[], &State)
}; };
// try to add module, exporting non-existant env' variable => error // try to add module, exporting non-existant env' variable => error
@ -281,7 +281,7 @@ fn native_custom_error() {
let user_error = match program.invoke_index( let user_error = match program.invoke_index(
"main", "main",
0, 0,
vec![RuntimeValue::I32(7), RuntimeValue::I32(0)], &[RuntimeValue::I32(7), RuntimeValue::I32(0)],
&mut state &mut state
) { ) {
Err(Error::User(user_error)) => user_error, Err(Error::User(user_error)) => user_error,
@ -347,7 +347,7 @@ fn native_ref_state() {
instance instance
.invoke_index( .invoke_index(
1, 1,
vec![RuntimeValue::I32(7), RuntimeValue::I32(2)], &[RuntimeValue::I32(7), RuntimeValue::I32(2)],
&mut host_state, &mut host_state,
) )
.expect("Invoke internal func successfully"); .expect("Invoke internal func successfully");

456
src/interpreter/tests/wabt.rs
View File

@ -23,7 +23,7 @@ fn make_function_i32(body: Opcodes) -> ProgramInstance {
fn run_function_i32(program: &mut ProgramInstance, arg: i32) -> Result<i32, Error> { fn run_function_i32(program: &mut ProgramInstance, arg: i32) -> Result<i32, Error> {
program program
.invoke_index("main", 0, vec![RuntimeValue::I32(arg)], &mut ()) .invoke_index("main", 0, &[RuntimeValue::I32(arg)], &mut ())
.and_then(|r| r.unwrap().try_into()) .and_then(|r| r.unwrap().try_into())
} }
@ -463,11 +463,11 @@ fn return_void() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
let module = program.add_module("main", module, &mut ()).unwrap(); let module = program.add_module("main", module, &mut ()).unwrap();
program.invoke_index("main", 0, vec![RuntimeValue::I32(0)], &mut ()).unwrap(); program.invoke_index("main", 0, &[RuntimeValue::I32(0)], &mut ()).unwrap();
let memory = module.memory_by_index(0).unwrap(); let memory = module.memory_by_index(0).unwrap();
assert_eq!(memory.get(0, 4).unwrap(), vec![0, 0, 0, 0]); assert_eq!(memory.get(0, 4).unwrap(), vec![0, 0, 0, 0]);
program.invoke_index("main", 0, vec![RuntimeValue::I32(1)], &mut ()).unwrap(); program.invoke_index("main", 0, &[RuntimeValue::I32(1)], &mut ()).unwrap();
let memory = module.memory_by_index(0).unwrap(); let memory = module.memory_by_index(0).unwrap();
assert_eq!(memory.get(0, 4).unwrap(), vec![1, 0, 0, 0]); assert_eq!(memory.get(0, 4).unwrap(), vec![1, 0, 0, 0]);
} }
@ -521,7 +521,7 @@ fn call_1() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(10)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(10));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/call.txt#L23 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/call.txt#L23
@ -568,7 +568,7 @@ fn call_2() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(3628800)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(3628800));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/call-zero-args.txt /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/call-zero-args.txt
@ -613,7 +613,7 @@ fn call_zero_args() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(43)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(43));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/callindirect.txt#L31 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/callindirect.txt#L31
@ -659,8 +659,8 @@ fn callindirect_1() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 2, vec![RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 2, &[RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 2, vec![RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 2, &[RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/callindirect.txt#L39 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/callindirect.txt#L39
@ -732,9 +732,9 @@ fn callindirect_2() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 3, vec![RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(14)); assert_eq!(program.invoke_index("main", 3, &[RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(14));
assert_eq!(program.invoke_index("main", 3, vec![RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(6)); assert_eq!(program.invoke_index("main", 3, &[RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(6));
match program.invoke_index("main", 3, vec![RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(2)], &mut ()) { match program.invoke_index("main", 3, &[RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(2)], &mut ()) {
Err(Error::Function(msg)) => { Err(Error::Function(msg)) => {
assert_eq!( assert_eq!(
&msg, &msg,
@ -743,7 +743,7 @@ fn callindirect_2() {
} }
result => panic!("Unexpected result {:?}", result), result => panic!("Unexpected result {:?}", result),
} }
match program.invoke_index("main", 3, vec![RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(3)], &mut ()) { match program.invoke_index("main", 3, &[RuntimeValue::I32(10), RuntimeValue::I32(4), RuntimeValue::I32(3)], &mut ()) {
Err(Error::Table(msg)) => { Err(Error::Table(msg)) => {
assert_eq!( assert_eq!(
&msg, &msg,
@ -814,14 +814,14 @@ fn select() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(2)); assert_eq!(program.invoke_index("main", 0, &[RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(2));
assert_eq!(program.invoke_index("main", 0, vec![RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 0, &[RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 1, vec![RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I64(2)); assert_eq!(program.invoke_index("main", 1, &[RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::I64(2));
assert_eq!(program.invoke_index("main", 1, vec![RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1)); assert_eq!(program.invoke_index("main", 1, &[RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1));
assert_eq!(program.invoke_index("main", 2, vec![RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::F32(2f32)); assert_eq!(program.invoke_index("main", 2, &[RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::F32(2f32));
assert_eq!(program.invoke_index("main", 2, vec![RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::F32(1f32)); assert_eq!(program.invoke_index("main", 2, &[RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::F32(1f32));
assert_eq!(program.invoke_index("main", 3, vec![RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::F64(2f64)); assert_eq!(program.invoke_index("main", 3, &[RuntimeValue::I32(0)], &mut ()).unwrap().unwrap(), RuntimeValue::F64(2f64));
assert_eq!(program.invoke_index("main", 3, vec![RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1f64)); assert_eq!(program.invoke_index("main", 3, &[RuntimeValue::I32(1)], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1f64));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L3 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L3
@ -967,21 +967,21 @@ fn binary_i32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(3)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(3));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(16)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(16));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(21)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(21));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-2)); // 4294967294 assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-2)); // 4294967294
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(2147483646)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(2147483646));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); // 4294967295 assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); // 4294967295
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(15)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(15));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(14)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(14));
assert_eq!(program.invoke_index("main", 10, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-800)); // 4294966496 assert_eq!(program.invoke_index("main", 10, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-800)); // 4294966496
assert_eq!(program.invoke_index("main", 11, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(536870899)); assert_eq!(program.invoke_index("main", 11, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(536870899));
assert_eq!(program.invoke_index("main", 12, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-13)); // 4294967283 assert_eq!(program.invoke_index("main", 12, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-13)); // 4294967283
assert_eq!(program.invoke_index("main", 13, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-793)); // 4294966503 assert_eq!(program.invoke_index("main", 13, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-793)); // 4294966503
assert_eq!(program.invoke_index("main", 14, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1610612749)); // 2684354547 assert_eq!(program.invoke_index("main", 14, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1610612749)); // 2684354547
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L65 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L65
@ -1127,21 +1127,21 @@ fn binary_i64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(3)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(3));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(16)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(16));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(21)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(21));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-2)); // 18446744073709551614 assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-2)); // 18446744073709551614
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(9223372036854775806)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(9223372036854775806));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); // 18446744073709551615 assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); // 18446744073709551615
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(15)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(15));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(14)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(14));
assert_eq!(program.invoke_index("main", 10, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-800)); // 18446744073709550816 assert_eq!(program.invoke_index("main", 10, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-800)); // 18446744073709550816
assert_eq!(program.invoke_index("main", 11, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(2305843009213693939)); assert_eq!(program.invoke_index("main", 11, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(2305843009213693939));
assert_eq!(program.invoke_index("main", 12, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-13)); // 18446744073709551603 assert_eq!(program.invoke_index("main", 12, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-13)); // 18446744073709551603
assert_eq!(program.invoke_index("main", 13, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-793)); // 18446744073709550823 assert_eq!(program.invoke_index("main", 13, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-793)); // 18446744073709550823
assert_eq!(program.invoke_index("main", 14, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-6917529027641081869)); // 11529215046068469747 assert_eq!(program.invoke_index("main", 14, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-6917529027641081869)); // 11529215046068469747
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L3 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L3
@ -1217,13 +1217,13 @@ fn binary_f32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(5.000000)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(5.000000));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-9995.500000)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-9995.500000));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-8487.187500)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-8487.187500));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-500000000.000000)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-500000000.000000));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L157 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/binary.txt#L157
@ -1299,15 +1299,15 @@ fn binary_f64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1111111110.000000)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1111111110.000000));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(123400000000000007812762268812638756607430593436581896388608.000000)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(123400000000000007812762268812638756607430593436581896388608.000000));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-15179717820000.000000)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-15179717820000.000000));
// in wabt result is 99999999999999998083559617243737459057312001403031879309116481015410011220367858297629826861622 // in wabt result is 99999999999999998083559617243737459057312001403031879309116481015410011220367858297629826861622
// but the actual (and correct) result is 1e150 // but the actual (and correct) result is 1e150
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1e150)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1e150));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/cast.txt /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/cast.txt
@ -1352,10 +1352,10 @@ fn cast() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(4.5)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(4.5));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1067450368)); // 3227516928 assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1067450368)); // 3227516928
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(125.125000)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(125.125000));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4758506566875873280)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4758506566875873280));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L3 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L3
@ -1618,34 +1618,34 @@ fn compare_i32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 10, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 10, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 11, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 11, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 12, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 12, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 13, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 13, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 14, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 14, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 15, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 15, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 16, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 16, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 17, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 17, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 18, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 18, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 19, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 19, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 20, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 20, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 21, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 21, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 22, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 22, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 23, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 23, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 24, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 24, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 25, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 25, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 26, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 26, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 27, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 27, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L123 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L123
@ -1908,34 +1908,34 @@ fn compare_i64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 10, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 10, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 11, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 11, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 12, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 12, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 13, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 13, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 14, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 14, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 15, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 15, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 16, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 16, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 17, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 17, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 18, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 18, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 19, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 19, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 20, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 20, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 21, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 21, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 22, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 22, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 23, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 23, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 24, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 24, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 25, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 25, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 26, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 26, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 27, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 27, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L246 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L246
@ -2092,22 +2092,22 @@ fn compare_f32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 10, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 10, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 11, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 11, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 12, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 12, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 13, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 13, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 14, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 14, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 15, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 15, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L317 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/compare.txt#L317
@ -2264,22 +2264,22 @@ fn compare_f64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 10, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 10, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 11, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 11, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 12, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 12, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 13, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 13, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 14, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 14, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 15, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 15, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L3 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L3
@ -2332,11 +2332,11 @@ fn convert_i32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); // 4294967295 assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); // 4294967295
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-100)); // 4294967196 assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-100)); // 4294967196
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1294967296)); // 3000000000 assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1294967296)); // 3000000000
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-100)); // 4294967196 assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-100)); // 4294967196
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1294967296)); // 3000000000 assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1294967296)); // 3000000000
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L21 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L21
@ -2405,12 +2405,12 @@ fn convert_i64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4294967295)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4294967295));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); // 18446744073709551615 assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); // 18446744073709551615
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L50 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L50
@ -2463,11 +2463,11 @@ fn convert_f32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-1.000000)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-1.000000));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(4294967296.000000)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(4294967296.000000));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(12345679.000000)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(12345679.000000));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(0.000000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L50 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/convert.txt#L50
@ -2520,11 +2520,11 @@ fn convert_f64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-1.000000)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-1.000000));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(4294967295.000000)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(4294967295.000000));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(12345679.000000)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(12345679.000000));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(0.000000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L9 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L9
@ -2580,11 +2580,11 @@ fn load_i32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(255)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(255));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(65535)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(65535));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L26 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L26
@ -2656,13 +2656,13 @@ fn load_i64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-1));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(255)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(255));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(65535)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(65535));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4294967295)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4294967295));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L50 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L50
@ -2686,7 +2686,7 @@ fn load_f32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(25.750000)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(25.750000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L54 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/load.txt#L54
@ -2710,7 +2710,7 @@ fn load_f64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1023.875000)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1023.875000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L5 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L5
@ -2767,9 +2767,9 @@ fn store_i32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-16909061)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-16909061));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-859059511)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-859059511));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-123456)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-123456));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L38 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L38
@ -2837,10 +2837,10 @@ fn store_i64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4278058235)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4278058235));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(3435907785)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(3435907785));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4294843840)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(4294843840));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-4981613551475109875)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(-4981613551475109875));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L78 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L78
@ -2865,7 +2865,7 @@ fn store_f32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1069547520)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1069547520));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L85 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/store.txt#L85
@ -2890,7 +2890,7 @@ fn store_f64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1064352256)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(-1064352256));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L12 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L12
@ -2941,11 +2941,11 @@ fn unary_i32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(24)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(24));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(7)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(7));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L29 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L29
@ -2996,11 +2996,11 @@ fn unary_i64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 0, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0)); assert_eq!(program.invoke_index("main", 0, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(56)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(56));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(7)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(7));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I64(1));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L46 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L46
@ -3095,15 +3095,15 @@ fn unary_f32() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-100.000000)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-100.000000));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(100.000000)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(100.000000));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(10.000000)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(10.000000));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-0.000000)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-0.000000));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-1.000000)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-1.000000));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-0.000000)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(-0.000000));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(1.000000)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(1.000000));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F32(2.000000)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F32(2.000000));
} }
/// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L76 /// https://github.com/WebAssembly/wabt/blob/8e1f6031e9889ba770c7be4a9b084da5f14456a0/test/interp/unary.txt#L76
@ -3198,13 +3198,13 @@ fn unary_f64() {
let mut program = ProgramInstance::new(); let mut program = ProgramInstance::new();
program.add_module("main", module, &mut ()).unwrap(); program.add_module("main", module, &mut ()).unwrap();
assert_eq!(program.invoke_index("main", 1, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-100.000000)); assert_eq!(program.invoke_index("main", 1, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-100.000000));
assert_eq!(program.invoke_index("main", 2, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(100.000000)); assert_eq!(program.invoke_index("main", 2, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(100.000000));
assert_eq!(program.invoke_index("main", 3, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1)); assert_eq!(program.invoke_index("main", 3, &[], &mut ()).unwrap().unwrap(), RuntimeValue::I32(1));
assert_eq!(program.invoke_index("main", 4, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(10.000000)); assert_eq!(program.invoke_index("main", 4, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(10.000000));
assert_eq!(program.invoke_index("main", 5, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-0.000000)); assert_eq!(program.invoke_index("main", 5, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-0.000000));
assert_eq!(program.invoke_index("main", 6, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-1.000000)); assert_eq!(program.invoke_index("main", 6, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-1.000000));
assert_eq!(program.invoke_index("main", 7, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-0.000000)); assert_eq!(program.invoke_index("main", 7, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(-0.000000));
assert_eq!(program.invoke_index("main", 8, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1.000000)); assert_eq!(program.invoke_index("main", 8, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(1.000000));
assert_eq!(program.invoke_index("main", 9, vec![], &mut ()).unwrap().unwrap(), RuntimeValue::F64(2.000000)); assert_eq!(program.invoke_index("main", 9, &[], &mut ()).unwrap().unwrap(), RuntimeValue::F64(2.000000));
} }

4
src/interpreter/tests/wasm.rs
View File

@ -16,7 +16,7 @@ fn interpreter_inc_i32() {
deserialize_file(WASM_FILE).expect("Failed to deserialize module from buffer"); deserialize_file(WASM_FILE).expect("Failed to deserialize module from buffer");
let i32_val = 42; let i32_val = 42;
// the functions expects a single i32 parameter // the functions expects a single i32 parameter
let args = vec![RuntimeValue::I32(i32_val)]; let args = &[RuntimeValue::I32(i32_val)];
let exp_retval = Some(RuntimeValue::I32(i32_val + 1)); let exp_retval = Some(RuntimeValue::I32(i32_val + 1));
let module_result = program.add_module("main", module, &mut ()); let module_result = program.add_module("main", module, &mut ());
@ -56,7 +56,7 @@ fn interpreter_accumulate_u8() {
let _ = env_memory.set(offset, BUF); let _ = env_memory.set(offset, BUF);
// Set up the function argument list and invoke the function // Set up the function argument list and invoke the function
let args = vec![RuntimeValue::I32(BUF.len() as i32), RuntimeValue::I32(offset as i32)]; let args = &[RuntimeValue::I32(BUF.len() as i32), RuntimeValue::I32(offset as i32)];
let retval = program let retval = program
.invoke_export("main", FUNCTION_NAME, args, &mut ()) .invoke_export("main", FUNCTION_NAME, args, &mut ())
.expect("Failed to execute function"); .expect("Failed to execute function");