mirror of
https://github.com/fluencelabs/wasmer
synced 2024-12-15 15:15:40 +00:00
1395 lines
46 KiB
Rust
1395 lines
46 KiB
Rust
// Rust test file autogenerated with cargo build (build/spectests.rs).
|
|
// Please do NOT modify it by hand, as it will be reset on next build.
|
|
// Test based on spectests/exports.wast
|
|
#![allow(
|
|
warnings,
|
|
dead_code
|
|
)]
|
|
use wabt::wat2wasm;
|
|
use std::{f32, f64};
|
|
|
|
use wasmer_runtime::types::Value;
|
|
use wasmer_runtime::{Instance, module::Module};
|
|
use wasmer_clif_backend::CraneliftCompiler;
|
|
|
|
use crate::spectests::_common::{
|
|
spectest_importobject,
|
|
NaNCheck,
|
|
};
|
|
|
|
|
|
// Line 3
|
|
fn create_module_1() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_1(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 4
|
|
|
|
#[test]
|
|
fn test_module_1() {
|
|
let mut instance = create_module_1();
|
|
// We group the calls together
|
|
start_module_1(&mut instance);
|
|
}
|
|
fn create_module_2() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0))
|
|
(export \"b\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_2(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 5
|
|
|
|
#[test]
|
|
fn test_module_2() {
|
|
let mut instance = create_module_2();
|
|
// We group the calls together
|
|
start_module_2(&mut instance);
|
|
}
|
|
fn create_module_3() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(func (;1;) (type 0))
|
|
(export \"a\" (func 0))
|
|
(export \"b\" (func 1)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_3(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 7
|
|
|
|
#[test]
|
|
fn test_module_3() {
|
|
let mut instance = create_module_3();
|
|
// We group the calls together
|
|
start_module_3(&mut instance);
|
|
}
|
|
fn create_module_4() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_4(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 8
|
|
|
|
#[test]
|
|
fn test_module_4() {
|
|
let mut instance = create_module_4();
|
|
// We group the calls together
|
|
start_module_4(&mut instance);
|
|
}
|
|
fn create_module_5() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0))
|
|
(export \"b\" (func 0))
|
|
(export \"c\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_5(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 9
|
|
|
|
#[test]
|
|
fn test_module_5() {
|
|
let mut instance = create_module_5();
|
|
// We group the calls together
|
|
start_module_5(&mut instance);
|
|
}
|
|
fn create_module_6() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func (param i32)))
|
|
(func (;0;) (type 0) (param i32))
|
|
(export \"a\" (func 0))
|
|
(export \"b\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_6(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 10
|
|
|
|
#[test]
|
|
fn test_module_6() {
|
|
let mut instance = create_module_6();
|
|
// We group the calls together
|
|
start_module_6(&mut instance);
|
|
}
|
|
fn create_module_7() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_7(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 11
|
|
|
|
#[test]
|
|
fn test_module_7() {
|
|
let mut instance = create_module_7();
|
|
// We group the calls together
|
|
start_module_7(&mut instance);
|
|
}
|
|
fn create_module_8() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_8(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 12
|
|
|
|
#[test]
|
|
fn test_module_8() {
|
|
let mut instance = create_module_8();
|
|
// We group the calls together
|
|
start_module_8(&mut instance);
|
|
}
|
|
fn create_module_9() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_9(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 13
|
|
|
|
#[test]
|
|
fn test_module_9() {
|
|
let mut instance = create_module_9();
|
|
// We group the calls together
|
|
start_module_9(&mut instance);
|
|
}
|
|
fn create_module_10() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_10(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 14
|
|
|
|
#[test]
|
|
fn test_module_10() {
|
|
let mut instance = create_module_10();
|
|
// We group the calls together
|
|
start_module_10(&mut instance);
|
|
}
|
|
fn create_module_11() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func))
|
|
(func (;0;) (type 0))
|
|
(export \"a\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_11(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 16
|
|
|
|
#[test]
|
|
fn test_module_11() {
|
|
let mut instance = create_module_11();
|
|
// We group the calls together
|
|
start_module_11(&mut instance);
|
|
}
|
|
fn create_module_12() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(type (;0;) (func (param i32) (result i32)))
|
|
(func (;0;) (type 0) (param i32) (result i32)
|
|
get_local 0
|
|
i32.const 1
|
|
i32.add
|
|
return)
|
|
(export \"e\" (func 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_12(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 22
|
|
fn c12_l22_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c12_l22_action_invoke");
|
|
let result = instance.call("e", &[Value::I32(42 as i32)]);
|
|
assert_eq!(result, Ok(Some(Value::I32(43 as i32))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 23
|
|
fn c13_l23_action_invoke(instance: &mut Instance) -> Result<(), String> {
|
|
println!("Executing function {}", "c13_l23_action_invoke");
|
|
let result = instance.call("e", &[Value::I32(42 as i32)]);
|
|
assert_eq!(result, Ok(Some(Value::I32(43 as i32))));
|
|
result.map(|_| ())
|
|
}
|
|
|
|
// Line 29
|
|
#[test]
|
|
fn c14_l29_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 5, 1, 1, 97, 0, 1, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 33
|
|
#[test]
|
|
fn c15_l33_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 37
|
|
#[test]
|
|
fn c16_l37_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 0, 1, 10, 7, 2, 2, 0, 11, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 41
|
|
#[test]
|
|
fn c17_l41_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 0, 0, 1, 97, 3, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 45
|
|
#[test]
|
|
fn c18_l45_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 1, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 49
|
|
#[test]
|
|
fn c19_l49_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 0, 0, 1, 97, 2, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 56
|
|
|
|
#[test]
|
|
fn test_module_12() {
|
|
let mut instance = create_module_12();
|
|
// We group the calls together
|
|
start_module_12(&mut instance);
|
|
c12_l22_action_invoke(&mut instance);
|
|
c13_l23_action_invoke(&mut instance);
|
|
}
|
|
fn create_module_13() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_13(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 57
|
|
|
|
#[test]
|
|
fn test_module_13() {
|
|
let mut instance = create_module_13();
|
|
// We group the calls together
|
|
start_module_13(&mut instance);
|
|
}
|
|
fn create_module_14() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0))
|
|
(export \"b\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_14(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 58
|
|
|
|
#[test]
|
|
fn test_module_14() {
|
|
let mut instance = create_module_14();
|
|
// We group the calls together
|
|
start_module_14(&mut instance);
|
|
}
|
|
fn create_module_15() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(global (;1;) i32 (i32.const 0))
|
|
(export \"a\" (global 0))
|
|
(export \"b\" (global 1)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_15(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 60
|
|
|
|
#[test]
|
|
fn test_module_15() {
|
|
let mut instance = create_module_15();
|
|
// We group the calls together
|
|
start_module_15(&mut instance);
|
|
}
|
|
fn create_module_16() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_16(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 61
|
|
|
|
#[test]
|
|
fn test_module_16() {
|
|
let mut instance = create_module_16();
|
|
// We group the calls together
|
|
start_module_16(&mut instance);
|
|
}
|
|
fn create_module_17() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_17(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 62
|
|
|
|
#[test]
|
|
fn test_module_17() {
|
|
let mut instance = create_module_17();
|
|
// We group the calls together
|
|
start_module_17(&mut instance);
|
|
}
|
|
fn create_module_18() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_18(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 63
|
|
|
|
#[test]
|
|
fn test_module_18() {
|
|
let mut instance = create_module_18();
|
|
// We group the calls together
|
|
start_module_18(&mut instance);
|
|
}
|
|
fn create_module_19() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_19(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 64
|
|
|
|
#[test]
|
|
fn test_module_19() {
|
|
let mut instance = create_module_19();
|
|
// We group the calls together
|
|
start_module_19(&mut instance);
|
|
}
|
|
fn create_module_20() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_20(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 65
|
|
|
|
#[test]
|
|
fn test_module_20() {
|
|
let mut instance = create_module_20();
|
|
// We group the calls together
|
|
start_module_20(&mut instance);
|
|
}
|
|
fn create_module_21() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 0))
|
|
(export \"a\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_21(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 67
|
|
|
|
#[test]
|
|
fn test_module_21() {
|
|
let mut instance = create_module_21();
|
|
// We group the calls together
|
|
start_module_21(&mut instance);
|
|
}
|
|
fn create_module_22() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(global (;0;) i32 (i32.const 42))
|
|
(export \"e\" (global 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_22(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 71
|
|
|
|
// Line 72
|
|
|
|
// Line 78
|
|
#[test]
|
|
fn c32_l78_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 5, 1, 1, 97, 3, 1];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 82
|
|
#[test]
|
|
fn c33_l82_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 86
|
|
#[test]
|
|
fn c34_l86_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 6, 11, 2, 127, 0, 65, 0, 11, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 3, 1];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 90
|
|
#[test]
|
|
fn c35_l90_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 94
|
|
#[test]
|
|
fn c36_l94_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 1, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 98
|
|
#[test]
|
|
fn c37_l98_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 3, 0, 1, 97, 2, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 105
|
|
|
|
#[test]
|
|
fn test_module_22() {
|
|
let mut instance = create_module_22();
|
|
// We group the calls together
|
|
start_module_22(&mut instance);
|
|
}
|
|
fn create_module_23() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_23(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 106
|
|
|
|
#[test]
|
|
fn test_module_23() {
|
|
let mut instance = create_module_23();
|
|
// We group the calls together
|
|
start_module_23(&mut instance);
|
|
}
|
|
fn create_module_24() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0))
|
|
(export \"b\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_24(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 110
|
|
|
|
#[test]
|
|
fn test_module_24() {
|
|
let mut instance = create_module_24();
|
|
// We group the calls together
|
|
start_module_24(&mut instance);
|
|
}
|
|
fn create_module_25() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_25(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 111
|
|
|
|
#[test]
|
|
fn test_module_25() {
|
|
let mut instance = create_module_25();
|
|
// We group the calls together
|
|
start_module_25(&mut instance);
|
|
}
|
|
fn create_module_26() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 1 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_26(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 112
|
|
|
|
#[test]
|
|
fn test_module_26() {
|
|
let mut instance = create_module_26();
|
|
// We group the calls together
|
|
start_module_26(&mut instance);
|
|
}
|
|
fn create_module_27() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_27(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 113
|
|
|
|
#[test]
|
|
fn test_module_27() {
|
|
let mut instance = create_module_27();
|
|
// We group the calls together
|
|
start_module_27(&mut instance);
|
|
}
|
|
fn create_module_28() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 1 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_28(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 114
|
|
|
|
#[test]
|
|
fn test_module_28() {
|
|
let mut instance = create_module_28();
|
|
// We group the calls together
|
|
start_module_28(&mut instance);
|
|
}
|
|
fn create_module_29() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_29(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 115
|
|
|
|
#[test]
|
|
fn test_module_29() {
|
|
let mut instance = create_module_29();
|
|
// We group the calls together
|
|
start_module_29(&mut instance);
|
|
}
|
|
fn create_module_30() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 1 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_30(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 116
|
|
|
|
#[test]
|
|
fn test_module_30() {
|
|
let mut instance = create_module_30();
|
|
// We group the calls together
|
|
start_module_30(&mut instance);
|
|
}
|
|
fn create_module_31() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_31(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 117
|
|
|
|
#[test]
|
|
fn test_module_31() {
|
|
let mut instance = create_module_31();
|
|
// We group the calls together
|
|
start_module_31(&mut instance);
|
|
}
|
|
fn create_module_32() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 1 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_32(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 118
|
|
|
|
#[test]
|
|
fn test_module_32() {
|
|
let mut instance = create_module_32();
|
|
// We group the calls together
|
|
start_module_32(&mut instance);
|
|
}
|
|
fn create_module_33() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_33(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 119
|
|
|
|
#[test]
|
|
fn test_module_33() {
|
|
let mut instance = create_module_33();
|
|
// We group the calls together
|
|
start_module_33(&mut instance);
|
|
}
|
|
fn create_module_34() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 1 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_34(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 120
|
|
|
|
#[test]
|
|
fn test_module_34() {
|
|
let mut instance = create_module_34();
|
|
// We group the calls together
|
|
start_module_34(&mut instance);
|
|
}
|
|
fn create_module_35() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_35(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 121
|
|
|
|
#[test]
|
|
fn test_module_35() {
|
|
let mut instance = create_module_35();
|
|
// We group the calls together
|
|
start_module_35(&mut instance);
|
|
}
|
|
fn create_module_36() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(table (;0;) 0 1 anyfunc)
|
|
(export \"a\" (table 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_36(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 126
|
|
#[test]
|
|
fn c52_l126_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 5, 1, 1, 97, 1, 1];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 130
|
|
#[test]
|
|
fn c53_l130_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 1, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 139
|
|
#[test]
|
|
fn c54_l139_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 143
|
|
#[test]
|
|
fn c55_l143_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 1, 0, 1, 97, 3, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 147
|
|
#[test]
|
|
fn c56_l147_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 1, 0, 1, 97, 2, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 154
|
|
|
|
#[test]
|
|
fn test_module_36() {
|
|
let mut instance = create_module_36();
|
|
// We group the calls together
|
|
start_module_36(&mut instance);
|
|
}
|
|
fn create_module_37() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_37(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 155
|
|
|
|
#[test]
|
|
fn test_module_37() {
|
|
let mut instance = create_module_37();
|
|
// We group the calls together
|
|
start_module_37(&mut instance);
|
|
}
|
|
fn create_module_38() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0))
|
|
(export \"b\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_38(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 159
|
|
|
|
#[test]
|
|
fn test_module_38() {
|
|
let mut instance = create_module_38();
|
|
// We group the calls together
|
|
start_module_38(&mut instance);
|
|
}
|
|
fn create_module_39() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_39(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 160
|
|
|
|
#[test]
|
|
fn test_module_39() {
|
|
let mut instance = create_module_39();
|
|
// We group the calls together
|
|
start_module_39(&mut instance);
|
|
}
|
|
fn create_module_40() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0 1)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_40(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 161
|
|
|
|
#[test]
|
|
fn test_module_40() {
|
|
let mut instance = create_module_40();
|
|
// We group the calls together
|
|
start_module_40(&mut instance);
|
|
}
|
|
fn create_module_41() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_41(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 162
|
|
|
|
#[test]
|
|
fn test_module_41() {
|
|
let mut instance = create_module_41();
|
|
// We group the calls together
|
|
start_module_41(&mut instance);
|
|
}
|
|
fn create_module_42() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0 1)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_42(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 163
|
|
|
|
#[test]
|
|
fn test_module_42() {
|
|
let mut instance = create_module_42();
|
|
// We group the calls together
|
|
start_module_42(&mut instance);
|
|
}
|
|
fn create_module_43() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_43(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 164
|
|
|
|
#[test]
|
|
fn test_module_43() {
|
|
let mut instance = create_module_43();
|
|
// We group the calls together
|
|
start_module_43(&mut instance);
|
|
}
|
|
fn create_module_44() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0 1)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_44(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 165
|
|
|
|
#[test]
|
|
fn test_module_44() {
|
|
let mut instance = create_module_44();
|
|
// We group the calls together
|
|
start_module_44(&mut instance);
|
|
}
|
|
fn create_module_45() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_45(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 166
|
|
|
|
#[test]
|
|
fn test_module_45() {
|
|
let mut instance = create_module_45();
|
|
// We group the calls together
|
|
start_module_45(&mut instance);
|
|
}
|
|
fn create_module_46() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0 1)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_46(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 167
|
|
|
|
#[test]
|
|
fn test_module_46() {
|
|
let mut instance = create_module_46();
|
|
// We group the calls together
|
|
start_module_46(&mut instance);
|
|
}
|
|
fn create_module_47() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_47(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 168
|
|
|
|
#[test]
|
|
fn test_module_47() {
|
|
let mut instance = create_module_47();
|
|
// We group the calls together
|
|
start_module_47(&mut instance);
|
|
}
|
|
fn create_module_48() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0 1)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_48(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 169
|
|
|
|
#[test]
|
|
fn test_module_48() {
|
|
let mut instance = create_module_48();
|
|
// We group the calls together
|
|
start_module_48(&mut instance);
|
|
}
|
|
fn create_module_49() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_49(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 170
|
|
|
|
#[test]
|
|
fn test_module_49() {
|
|
let mut instance = create_module_49();
|
|
// We group the calls together
|
|
start_module_49(&mut instance);
|
|
}
|
|
fn create_module_50() -> Box<Instance> {
|
|
let module_str = "(module
|
|
(memory (;0;) 0 1)
|
|
(export \"a\" (memory 0)))
|
|
";
|
|
let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed");
|
|
let module = wasmer_runtime::compile(&wasm_binary[..], &CraneliftCompiler::new()).expect("WASM can't be compiled");
|
|
module.instantiate(&spectest_importobject()).expect("WASM can't be instantiated")
|
|
}
|
|
|
|
fn start_module_50(instance: &mut Instance) {
|
|
// TODO Review is explicit start needed? Start now called in runtime::Instance::new()
|
|
//instance.start();
|
|
}
|
|
|
|
// Line 175
|
|
#[test]
|
|
fn c71_l175_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 5, 1, 1, 97, 2, 1];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 179
|
|
#[test]
|
|
fn c72_l179_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 2, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 188
|
|
#[test]
|
|
fn c73_l188_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 0, 0, 10, 4, 1, 2, 0, 11];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 192
|
|
#[test]
|
|
fn c74_l192_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 5, 3, 1, 0, 0, 6, 6, 1, 127, 0, 65, 0, 11, 7, 9, 2, 1, 97, 2, 0, 1, 97, 3, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
// Line 196
|
|
#[test]
|
|
fn c75_l196_assert_invalid() {
|
|
let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 0, 7, 9, 2, 1, 97, 2, 0, 1, 97, 1, 0];
|
|
let module = wasmer_runtime::compile(&wasm_binary, &CraneliftCompiler::new());
|
|
assert!(module.is_err(), "WASM should not compile as is invalid");
|
|
}
|
|
|
|
#[test]
|
|
fn test_module_50() {
|
|
let mut instance = create_module_50();
|
|
// We group the calls together
|
|
start_module_50(&mut instance);
|
|
}
|