mii/wasmer
1
0
Fork 0
mirror of https://github.com/mii443/wasmer.git synced 2025-12-16 17:18:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move Webassembly objects to Store and remove Context

Browse Source 
Co-authored-by: ptitSeb <sebastien.chev@gmail.com>
Co-authored-by: Manos Pitsidianakis <manos@wasmer.io>
This commit is contained in:
Syrus Akbary
2022-07-08 15:33:29 -07:00
committed by Manos Pitsidianakis
parent b5ae6399ce
commit a419ccdf52
214 changed files with 5800 additions and 5759 deletions
Download Patch File Download Diff File Expand all files Collapse all files

487
lib/api/tests/sys_externals.rs
View File

@@ -1,25 +1,24 @@
#[cfg(feature = "sys")]
mod sys {
use anyhow::Result;
use wasmer::Context as WasmerContext;
use wasmer::FunctionEnv;
use wasmer::*;
#[test]
fn global_new() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let global = Global::new(&mut ctx, Value::I32(10));
let mut store = Store::default();
let global = Global::new(&mut store, Value::I32(10));
assert_eq!(
global.ty(&mut ctx),
global.ty(&mut store),
GlobalType {
ty: Type::I32,
mutability: Mutability::Const
}
);
let global_mut = Global::new_mut(&mut ctx, Value::I32(10));
let global_mut = Global::new_mut(&mut store, Value::I32(10));
assert_eq!(
global_mut.ty(&mut ctx),
global_mut.ty(&mut store),
GlobalType {
ty: Type::I32,
mutability: Mutability::Var
@@ -31,51 +30,49 @@ mod sys {
#[test]
fn global_get() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let global_i32 = Global::new(&mut ctx, Value::I32(10));
assert_eq!(global_i32.get(&mut ctx), Value::I32(10));
let global_i64 = Global::new(&mut ctx, Value::I64(20));
assert_eq!(global_i64.get(&mut ctx), Value::I64(20));
let global_f32 = Global::new(&mut ctx, Value::F32(10.0));
assert_eq!(global_f32.get(&mut ctx), Value::F32(10.0));
let global_f64 = Global::new(&mut ctx, Value::F64(20.0));
assert_eq!(global_f64.get(&mut ctx), Value::F64(20.0));
let mut store = Store::default();
let global_i32 = Global::new(&mut store, Value::I32(10));
assert_eq!(global_i32.get(&mut store), Value::I32(10));
let global_i64 = Global::new(&mut store, Value::I64(20));
assert_eq!(global_i64.get(&mut store), Value::I64(20));
let global_f32 = Global::new(&mut store, Value::F32(10.0));
assert_eq!(global_f32.get(&mut store), Value::F32(10.0));
let global_f64 = Global::new(&mut store, Value::F64(20.0));
assert_eq!(global_f64.get(&mut store), Value::F64(20.0));
Ok(())
}
#[test]
fn global_set() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let global_i32 = Global::new(&mut ctx, Value::I32(10));
let mut store = Store::default();
let global_i32 = Global::new(&mut store, Value::I32(10));
// Set on a constant should error
assert!(global_i32.set(&mut ctx, Value::I32(20)).is_err());
assert!(global_i32.set(&mut store, Value::I32(20)).is_err());
let global_i32_mut = Global::new_mut(&mut ctx, Value::I32(10));
let global_i32_mut = Global::new_mut(&mut store, Value::I32(10));
// Set on different type should error
assert!(global_i32_mut.set(&mut ctx, Value::I64(20)).is_err());
assert!(global_i32_mut.set(&mut store, Value::I64(20)).is_err());
// Set on same type should succeed
global_i32_mut.set(&mut ctx, Value::I32(20))?;
assert_eq!(global_i32_mut.get(&mut ctx), Value::I32(20));
global_i32_mut.set(&mut store, Value::I32(20))?;
assert_eq!(global_i32_mut.get(&mut store), Value::I32(20));
Ok(())
}
#[test]
fn table_new() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let mut store = Store::default();
let table_type = TableType {
ty: Type::FuncRef,
minimum: 0,
maximum: None,
};
let f = Function::new_native(&mut ctx, |_ctx: ContextMut<()>| {});
let table = Table::new(&mut ctx, table_type, Value::FuncRef(Some(f)))?;
assert_eq!(table.ty(&mut ctx), table_type);
let env = FunctionEnv::new(&mut store, ());
let f = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>| {});
let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f)))?;
assert_eq!(table.ty(&mut store), table_type);
// Anyrefs not yet supported
// let table_type = TableType {
@@ -92,17 +89,19 @@ mod sys {
#[test]
#[ignore]
fn table_get() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let mut store = Store::default();
let env = FunctionEnv::new(&mut store, ());
let table_type = TableType {
ty: Type::FuncRef,
minimum: 0,
maximum: Some(1),
};
let f = Function::new_native(&mut ctx, |_ctx: ContextMut<()>, num: i32| num + 1);
let table = Table::new(&mut ctx, table_type, Value::FuncRef(Some(f)))?;
assert_eq!(table.ty(&mut ctx), table_type);
let _elem = table.get(&mut ctx, 0).unwrap();
let f = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>, num: i32| {
num + 1
});
let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f)))?;
assert_eq!(table.ty(&mut store), table_type);
let _elem = table.get(&mut store, 0).unwrap();
// assert_eq!(elem.funcref().unwrap(), f);
Ok(())
}
@@ -116,21 +115,23 @@ mod sys {
#[test]
fn table_grow() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let mut store = Store::default();
let env = FunctionEnv::new(&mut store, ());
let table_type = TableType {
ty: Type::FuncRef,
minimum: 0,
maximum: Some(10),
};
let f = Function::new_native(&mut ctx, |_ctx: ContextMut<()>, num: i32| num + 1);
let table = Table::new(&mut ctx, table_type, Value::FuncRef(Some(f.clone())))?;
let f = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>, num: i32| {
num + 1
});
let table = Table::new(&mut store, table_type, Value::FuncRef(Some(f.clone())))?;
// Growing to a bigger maximum should return None
let old_len = table.grow(&mut ctx, 12, Value::FuncRef(Some(f.clone())));
let old_len = table.grow(&mut store, 12, Value::FuncRef(Some(f.clone())));
assert!(old_len.is_err());
// Growing to a bigger maximum should return None
let old_len = table.grow(&mut ctx, 5, Value::FuncRef(Some(f)))?;
let old_len = table.grow(&mut store, 5, Value::FuncRef(Some(f)))?;
assert_eq!(old_len, 0);
Ok(())
@@ -145,32 +146,30 @@ mod sys {
#[test]
fn memory_new() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let mut store = Store::default();
let memory_type = MemoryType {
shared: false,
minimum: Pages(0),
maximum: Some(Pages(10)),
};
let memory = Memory::new(&mut ctx, memory_type)?;
assert_eq!(memory.size(&mut ctx), Pages(0));
assert_eq!(memory.ty(&mut ctx), memory_type);
let memory = Memory::new(&mut store, memory_type)?;
assert_eq!(memory.size(&mut store), Pages(0));
assert_eq!(memory.ty(&mut store), memory_type);
Ok(())
}
#[test]
fn memory_grow() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let mut store = Store::default();
let desc = MemoryType::new(Pages(10), Some(Pages(16)), false);
let memory = Memory::new(&mut ctx, desc)?;
assert_eq!(memory.size(&mut ctx), Pages(10));
let memory = Memory::new(&mut store, desc)?;
assert_eq!(memory.size(&mut store), Pages(10));
let result = memory.grow(&mut ctx, Pages(2)).unwrap();
let result = memory.grow(&mut store, Pages(2)).unwrap();
assert_eq!(result, Pages(10));
assert_eq!(memory.size(&mut ctx), Pages(12));
assert_eq!(memory.size(&mut store), Pages(12));
let result = memory.grow(&mut ctx, Pages(10));
let result = memory.grow(&mut store, Pages(10));
assert_eq!(
result,
Err(MemoryError::CouldNotGrow {
@@ -180,7 +179,7 @@ mod sys {
);
let bad_desc = MemoryType::new(Pages(15), Some(Pages(10)), false);
let bad_result = Memory::new(&mut ctx, bad_desc);
let bad_result = Memory::new(&mut store, bad_desc);
assert!(matches!(bad_result, Err(MemoryError::InvalidMemory { .. })));
@@ -189,37 +188,41 @@ mod sys {
#[test]
fn function_new() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<_>| {});
let mut store = Store::default();
let env = FunctionEnv::new(&mut store, ());
let function = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>| {});
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![], vec![])
);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<_>, _a: i32| {});
let function =
Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>, _a: i32| {});
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![Type::I32], vec![])
);
let function = Function::new_native(
&mut ctx,
|_ctx: ContextMut<_>, _a: i32, _b: i64, _c: f32, _d: f64| {},
&mut store,
&env,
|_ctx: FunctionEnvMut<()>, _a: i32, _b: i64, _c: f32, _d: f64| {},
);
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![])
);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<_>| -> i32 { 1 });
let function =
Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>| -> i32 { 1 });
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![], vec![Type::I32])
);
let function =
Function::new_native(&mut ctx, |_ctx: ContextMut<_>| -> (i32, i64, f32, f64) {
(1, 2, 3.0, 4.0)
});
let function = Function::new_native(
&mut store,
&env,
|_ctx: FunctionEnvMut<()>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) },
);
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
);
Ok(())
@@ -227,41 +230,45 @@ mod sys {
#[test]
fn function_new_env() -> Result<()> {
let store = Store::default();
let mut store = Store::default();
#[derive(Clone)]
struct MyEnv {}
let my_env = MyEnv {};
let mut ctx = WasmerContext::new(&store, my_env);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<MyEnv>| {});
let env = FunctionEnv::new(&mut store, my_env);
let function = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<MyEnv>| {});
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![], vec![])
);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<MyEnv>, _a: i32| {});
let function =
Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<MyEnv>, _a: i32| {});
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![Type::I32], vec![])
);
let function = Function::new_native(
&mut ctx,
|_ctx: ContextMut<MyEnv>, _a: i32, _b: i64, _c: f32, _d: f64| {},
&mut store,
&env,
|_ctx: FunctionEnvMut<MyEnv>, _a: i32, _b: i64, _c: f32, _d: f64| {},
);
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![])
);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<MyEnv>| -> i32 { 1 });
let function =
Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<MyEnv>| -> i32 { 1 });
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![], vec![Type::I32])
);
let function = Function::new_native(
&mut ctx,
|_ctx: ContextMut<MyEnv>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) },
&mut store,
&env,
|_ctx: FunctionEnvMut<MyEnv>| -> (i32, i64, f32, f64) { (1, 2, 3.0, 4.0) },
);
assert_eq!(
function.ty(&mut ctx).clone(),
function.ty(&mut store).clone(),
FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64])
);
Ok(())
@@ -269,58 +276,64 @@ mod sys {
#[test]
fn function_new_dynamic() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let mut store = Store::default();
let env = FunctionEnv::new(&mut store, ());
// Using &FunctionType signature
let function_type = FunctionType::new(vec![], vec![]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<()>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<()>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type = FunctionType::new(vec![Type::I32], vec![]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<()>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<()>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type =
FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<()>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<()>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type = FunctionType::new(vec![], vec![Type::I32]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<()>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<()>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type =
FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<()>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<()>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
// Using array signature
let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
function_type,
|_ctx: ContextMut<()>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<()>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).params(), [Type::V128]);
assert_eq!(function.ty(&mut store).params(), [Type::V128]);
assert_eq!(
function.ty(&mut ctx).results(),
function.ty(&mut store).results(),
[Type::I32, Type::F32, Type::F64]
);
@@ -329,193 +342,199 @@ mod sys {
#[test]
fn function_new_dynamic_env() -> Result<()> {
let store = Store::default();
let mut store = Store::default();
#[derive(Clone)]
struct MyEnv {}
let my_env = MyEnv {};
let mut ctx = WasmerContext::new(&store, my_env);
let env = FunctionEnv::new(&mut store, my_env);
// Using &FunctionType signature
let function_type = FunctionType::new(vec![], vec![]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<MyEnv>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type = FunctionType::new(vec![Type::I32], vec![]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<MyEnv>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type =
FunctionType::new(vec![Type::I32, Type::I64, Type::F32, Type::F64], vec![]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<MyEnv>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type = FunctionType::new(vec![], vec![Type::I32]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<MyEnv>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
let function_type =
FunctionType::new(vec![], vec![Type::I32, Type::I64, Type::F32, Type::F64]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
&function_type,
|_ctx: ContextMut<MyEnv>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).clone(), function_type);
assert_eq!(function.ty(&mut store).clone(), function_type);
// Using array signature
let function_type = ([Type::V128], [Type::I32, Type::F32, Type::F64]);
let function = Function::new(
&mut ctx,
&mut store,
&env,
function_type,
|_ctx: ContextMut<MyEnv>, _values: &[Value]| unimplemented!(),
|_ctx: FunctionEnvMut<MyEnv>, _values: &[Value]| unimplemented!(),
);
assert_eq!(function.ty(&mut ctx).params(), [Type::V128]);
assert_eq!(function.ty(&mut store).params(), [Type::V128]);
assert_eq!(
function.ty(&mut ctx).results(),
function.ty(&mut store).results(),
[Type::I32, Type::F32, Type::F64]
);
Ok(())
}
#[test]
fn native_function_works() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<()>| {});
let native_function: TypedFunction<(), ()> = function.native(&mut ctx).unwrap();
let result = native_function.call(&mut ctx);
assert!(result.is_ok());
// #[test]
// fn native_function_works() -> Result<()> {
// let mut store = Store::default();
// let env = FunctionEnv::new(&mut store, ());
// let function = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>| {});
// let native_function: TypedFunction<(), ()> = function.native(&mut store).unwrap();
// let result = native_function.call(&mut store);
// assert!(result.is_ok());
let function =
Function::new_native(&mut ctx, |_ctx: ContextMut<()>, a: i32| -> i32 { a + 1 });
let native_function: TypedFunction<i32, i32> = function.native(&mut ctx).unwrap();
assert_eq!(native_function.call(&mut ctx, 3).unwrap(), 4);
// let function =
// Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>, a: i32| -> i32 { a + 1 });
// let native_function: TypedFunction<i32, i32> = function.native(&mut store).unwrap();
// assert_eq!(native_function.call(&mut store, 3).unwrap(), 4);
fn rust_abi(_ctx: ContextMut<()>, a: i32, b: i64, c: f32, d: f64) -> u64 {
(a as u64 * 1000) + (b as u64 * 100) + (c as u64 * 10) + (d as u64)
}
let function = Function::new_native(&mut ctx, rust_abi);
let native_function: TypedFunction<(i32, i64, f32, f64), u64> =
function.native(&mut ctx).unwrap();
assert_eq!(native_function.call(&mut ctx, 8, 4, 1.5, 5.).unwrap(), 8415);
// fn rust_abi(_ctx: FunctionEnvMut<()>, a: i32, b: i64, c: f32, d: f64) -> u64 {
// (a as u64 * 1000) + (b as u64 * 100) + (c as u64 * 10) + (d as u64)
// }
// let function = Function::new_native(&mut store, &env, rust_abi);
// let native_function: TypedFunction<(i32, i64, f32, f64), u64> =
// function.native(&mut store).unwrap();
// assert_eq!(native_function.call(&mut store, 8, 4, 1.5, 5.).unwrap(), 8415);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<()>| -> i32 { 1 });
let native_function: TypedFunction<(), i32> = function.native(&mut ctx).unwrap();
assert_eq!(native_function.call(&mut ctx).unwrap(), 1);
// let function = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>| -> i32 { 1 });
// let native_function: TypedFunction<(), i32> = function.native(&mut store).unwrap();
// assert_eq!(native_function.call(&mut store).unwrap(), 1);
let function = Function::new_native(&mut ctx, |_ctx: ContextMut<()>, _a: i32| {});
let native_function: TypedFunction<i32, ()> = function.native(&mut ctx).unwrap();
assert!(native_function.call(&mut ctx, 4).is_ok());
// let function = Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>, _a: i32| {});
// let native_function: TypedFunction<i32, ()> = function.native(&mut store).unwrap();
// assert!(native_function.call(&mut store, 4).is_ok());
let function =
Function::new_native(&mut ctx, |_ctx: ContextMut<()>| -> (i32, i64, f32, f64) {
(1, 2, 3.0, 4.0)
});
let native_function: TypedFunction<(), (i32, i64, f32, f64)> =
function.native(&mut ctx).unwrap();
assert_eq!(native_function.call(&mut ctx).unwrap(), (1, 2, 3.0, 4.0));
// let function =
// Function::new_native(&mut store, &env, |_ctx: FunctionEnvMut<()>| -> (i32, i64, f32, f64) {
// (1, 2, 3.0, 4.0)
// });
// let native_function: TypedFunction<(), (i32, i64, f32, f64)> =
// function.native(&mut store).unwrap();
// assert_eq!(native_function.call(&mut store).unwrap(), (1, 2, 3.0, 4.0));
Ok(())
}
// Ok(())
// }
#[test]
fn function_outlives_instance() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let wat = r#"(module
(type $sum_t (func (param i32 i32) (result i32)))
(func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
local.get $x
local.get $y
i32.add)
(export "sum" (func $sum_f)))
"#;
// #[test]
// fn function_outlives_instance() -> Result<()> {
// let mut store = Store::default();
// let env = FunctionEnv::new(&mut store, ());
// let wat = r#"(module
// (type $sum_t (func (param i32 i32) (result i32)))
// (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
// local.get $x
// local.get $y
// i32.add)
// (export "sum" (func $sum_f)))
// "#;
let f = {
let module = Module::new(&store, wat)?;
let instance = Instance::new(&mut ctx, &module, &imports! {})?;
let f: TypedFunction<(i32, i32), i32> =
instance.exports.get_typed_function(&mut ctx, "sum")?;
// let f = {
// let module = Module::new(&store, wat)?;
// let instance = Instance::new(&mut store, &module, &imports! {})?;
// let f: TypedFunction<(i32, i32), i32> =
// instance.exports.get_typed_function(&mut store, "sum")?;
assert_eq!(f.call(&mut ctx, 4, 5)?, 9);
f
};
// assert_eq!(f.call(&mut store, 4, 5)?, 9);
// f
// };
assert_eq!(f.call(&mut ctx, 4, 5)?, 9);
// assert_eq!(f.call(&mut store, 4, 5)?, 9);
Ok(())
}
/*
#[test]
fn weak_instance_ref_externs_after_instance() -> Result<()> {
let store = Store::default();
let mut ctx = WasmerContext::new(&store, ());
let wat = r#"(module
(memory (export "mem") 1)
(type $sum_t (func (param i32 i32) (result i32)))
(func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
local.get $x
local.get $y
i32.add)
(export "sum" (func $sum_f)))
"#;
// Ok(())
// }
// /*
// #[test]
// fn weak_instance_ref_externs_after_instance() -> Result<()> {
// let mut store = Store::default();
// let env = FunctionEnv::new(&mut store, ());
// let wat = r#"(module
// (memory (export "mem") 1)
// (type $sum_t (func (param i32 i32) (result i32)))
// (func $sum_f (type $sum_t) (param $x i32) (param $y i32) (result i32)
// local.get $x
// local.get $y
// i32.add)
// (export "sum" (func $sum_f)))
// "#;
let f = {
let module = Module::new(&store, wat)?;
let instance = Instance::new(&mut ctx, &module, &imports! {})?;
let f: TypedFunction<(i32, i32), i32> =
instance.exports.get_with_generics_weak("sum")?;
// let f = {
// let module = Module::new(&store, wat)?;
// let instance = Instance::new(&mut store, &module, &imports! {})?;
// let f: TypedFunction<(i32, i32), i32> =
// instance.exports.get_with_generics_weak("sum")?;
assert_eq!(f.call(&mut ctx, 4, 5)?, 9);
f
};
// assert_eq!(f.call(&mut store, 4, 5)?, 9);
// f
// };
assert_eq!(f.call(&mut ctx, 4, 5)?, 9);
// assert_eq!(f.call(&mut store, 4, 5)?, 9);
Ok(())
}
*/
#[test]
fn manually_generate_wasmer_env() -> Result<()> {
let store = Store::default();
#[derive(Clone)]
struct MyEnv {
val: u32,
memory: Option<Memory>,
}
// Ok(())
// }
// */
// #[test]
// fn manually_generate_wasmer_env() -> Result<()> {
// let mut store = Store::default();
// #[derive(Clone)]
// struct MyEnv {
// val: u32,
// memory: Option<Memory>,
// }
fn host_function(ctx: ContextMut<MyEnv>, arg1: u32, arg2: u32) -> u32 {
ctx.data().val + arg1 + arg2
}
// fn host_function(ctx: FunctionEnvMut<MyEnv>, arg1: u32, arg2: u32) -> u32 {
// ctx.data().val + arg1 + arg2
// }
let mut env = MyEnv {
val: 5,
memory: None,
};
let mut ctx = WasmerContext::new(&store, env);
// let mut env = MyEnv {
// val: 5,
// memory: None,
// };
// let env = FunctionEnv::new(&mut store, env);
let result = host_function(ctx.as_context_mut(), 7, 9);
assert_eq!(result, 21);
// let result = host_function(ctx.as_context_mut(), 7, 9);
// assert_eq!(result, 21);
let memory = Memory::new(&mut ctx, MemoryType::new(0, None, false))?;
ctx.data_mut().memory = Some(memory);
// let memory = Memory::new(&mut store, MemoryType::new(0, None, false))?;
// ctx.as_mut(&mut store).memory = Some(memory);
let result = host_function(ctx.as_context_mut(), 1, 2);
assert_eq!(result, 8);
// let result = host_function(ctx.as_context_mut(), 1, 2);
// assert_eq!(result, 8);
Ok(())
}
// Ok(())
// }
}