From c97312345e26c86d10cd3f02015dc3724edb8176 Mon Sep 17 00:00:00 2001 From: Syrus Akbary Date: Sun, 28 Oct 2018 22:00:04 +0100 Subject: [PATCH] Test 'tee_local' and 'set_global' in more operators Based on this commit from the WebAssembly spec tests: https://github.com/WebAssembly/spec/commit/c90bc9686f1a90b76fb2ec782256d26323164c91 --- spectests/block.wast | 11 + spectests/br.wast | 9 + spectests/br_if.wast | 19 + spectests/br_table.wast | 17 +- spectests/call.wast | 118 +++ spectests/call_indirect.wast | 11 + src/integrations/mod.rs | 22 + src/spectests/block.rs | 1029 ++++++++++--------- src/spectests/br.rs | 660 ++++++------ src/spectests/br_if.rs | 779 ++++++++------- src/spectests/br_table.rs | 1710 ++++++++++++++++---------------- src/spectests/call.rs | 794 +++++++++++---- src/spectests/call_indirect.rs | 825 +++++++-------- src/webassembly/memory.rs | 2 +- 14 files changed, 3418 insertions(+), 2588 deletions(-) diff --git a/spectests/block.wast b/spectests/block.wast index 6ee79432b..4879e8bf8 100644 --- a/spectests/block.wast +++ b/spectests/block.wast @@ -167,6 +167,15 @@ (func (export "as-set_local-value") (result i32) (local i32) (set_local 0 (block (result i32) (i32.const 1))) (get_local 0) ) + (func (export "as-tee_local-value") (result i32) + (local i32) (tee_local 0 (block (result i32) (i32.const 1))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-set_global-value") (result i32) + (set_global $a (block (result i32) (i32.const 1))) + (get_global $a) + ) + (func (export "as-load-operand") (result i32) (i32.load (block (result i32) (i32.const 1))) ) @@ -277,6 +286,8 @@ (assert_return (invoke "as-drop-operand")) (assert_return (invoke "as-br-value") (i32.const 1)) (assert_return (invoke "as-set_local-value") (i32.const 1)) +(assert_return (invoke "as-tee_local-value") (i32.const 1)) +(assert_return (invoke "as-set_global-value") (i32.const 1)) (assert_return (invoke "as-load-operand") (i32.const 1)) (assert_return (invoke "as-unary-operand") (i32.const 0)) diff --git a/spectests/br.wast b/spectests/br.wast index e801a1b47..6624af1fe 100644 --- a/spectests/br.wast +++ b/spectests/br.wast @@ -181,6 +181,13 @@ (func (export "as-set_local-value") (result i32) (local f32) (block (result i32) (set_local 0 (br 0 (i32.const 17))) (i32.const -1)) ) + (func (export "as-tee_local-value") (result i32) (local i32) + (block (result i32) (tee_local 0 (br 0 (i32.const 1)))) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-set_global-value") (result i32) + (block (result i32) (set_global $a (br 0 (i32.const 1)))) + ) (memory 1) (func (export "as-load-address") (result f32) @@ -377,6 +384,8 @@ (assert_return (invoke "as-call_indirect-last") (i32.const 23)) (assert_return (invoke "as-set_local-value") (i32.const 17)) +(assert_return (invoke "as-tee_local-value") (i32.const 1)) +(assert_return (invoke "as-set_global-value") (i32.const 1)) (assert_return (invoke "as-load-address") (f32.const 1.7)) (assert_return (invoke "as-loadN-address") (i64.const 30)) diff --git a/spectests/br_if.wast b/spectests/br_if.wast index fbf0ed789..1ba584498 100644 --- a/spectests/br_if.wast +++ b/spectests/br_if.wast @@ -205,6 +205,19 @@ (i32.const -1) ) ) + (func (export "as-tee_local-value") (param i32) (result i32) + (block (result i32) + (tee_local 0 (br_if 0 (i32.const 1) (get_local 0))) + (return (i32.const -1)) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-set_global-value") (param i32) (result i32) + (block (result i32) + (set_global $a (br_if 0 (i32.const 1) (get_local 0))) + (return (i32.const -1)) + ) + ) (func (export "as-unary-operand") (result f64) (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1)))) @@ -391,6 +404,12 @@ (assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const -1)) (assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 17)) +(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1)) + +(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const -1)) +(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1)) + (assert_return (invoke "as-unary-operand") (f64.const 1.0)) (assert_return (invoke "as-binary-left") (i32.const 1)) (assert_return (invoke "as-binary-right") (i32.const 1)) diff --git a/spectests/br_table.wast b/spectests/br_table.wast index 7dc787b6b..69bc323ef 100644 --- a/spectests/br_table.wast +++ b/spectests/br_table.wast @@ -1027,6 +1027,20 @@ (i32.const -1) ) ) + (func (export "as-tee_local-value") (result i32) + (local i32) + (block (result i32) + (set_local 0 (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-set_global-value") (result i32) + (block (result i32) + (set_global $a (br_table 0 (i32.const 1) (i32.const 1))) + (i32.const -1) + ) + ) (memory 1) (func (export "as-load-address") (result f32) @@ -1342,6 +1356,8 @@ (assert_return (invoke "as-call_indirect-func") (i32.const 23)) (assert_return (invoke "as-set_local-value") (i32.const 17)) +(assert_return (invoke "as-tee_local-value") (i32.const 1)) +(assert_return (invoke "as-set_global-value") (i32.const 1)) (assert_return (invoke "as-load-address") (f32.const 1.7)) (assert_return (invoke "as-loadN-address") (i64.const 30)) @@ -1512,4 +1528,3 @@ )) "unknown label" ) - diff --git a/spectests/call.wast b/spectests/call.wast index 3a89f2323..bbc1a7a54 100644 --- a/spectests/call.wast +++ b/spectests/call.wast @@ -106,6 +106,97 @@ (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2)) (func $mutual-runaway2 (call $mutual-runaway1)) + + ;; As parameter of control constructs and instructions + + (memory 1) + + (func (export "as-select-first") (result i32) + (select (call $const-i32) (i32.const 2) (i32.const 3)) + ) + (func (export "as-select-mid") (result i32) + (select (i32.const 2) (call $const-i32) (i32.const 3)) + ) + (func (export "as-select-last") (result i32) + (select (i32.const 2) (i32.const 3) (call $const-i32)) + ) + + (func (export "as-if-condition") (result i32) + (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2))) + ) + + (func (export "as-br_if-first") (result i32) + (block (result i32) (br_if 0 (call $const-i32) (i32.const 2))) + ) + (func (export "as-br_if-last") (result i32) + (block (result i32) (br_if 0 (i32.const 2) (call $const-i32))) + ) + + (func (export "as-br_table-first") (result i32) + (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0)) + ) + (func (export "as-br_table-last") (result i32) + (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0)) + ) + + (func $func (param i32 i32) (result i32) (get_local 0)) + (type $check (func (param i32 i32) (result i32))) + (table anyfunc (elem $func)) + (func (export "as-call_indirect-first") (result i32) + (block (result i32) + (call_indirect (type $check) + (call $const-i32) (i32.const 2) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-mid") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 2) (call $const-i32) (i32.const 0) + ) + ) + ) + (func (export "as-call_indirect-last") (result i32) + (block (result i32) + (call_indirect (type $check) + (i32.const 1) (i32.const 2) (call $const-i32) + ) + ) + ) + + (func (export "as-store-first") + (call $const-i32) (i32.const 1) (i32.store) + ) + (func (export "as-store-last") + (i32.const 10) (call $const-i32) (i32.store) + ) + + (func (export "as-memory.grow-value") (result i32) + (memory.grow (call $const-i32)) + ) + (func (export "as-return-value") (result i32) + (call $const-i32) (return) + ) + (func (export "as-drop-operand") + (call $const-i32) (drop) + ) + (func (export "as-br-value") (result i32) + (block (result i32) (br 0 (call $const-i32))) + ) + (func (export "as-set_local-value") (result i32) + (local i32) (set_local 0 (call $const-i32)) (get_local 0) + ) + (func (export "as-tee_local-value") (result i32) + (local i32) (tee_local 0 (call $const-i32)) + ) + (global $a (mut i32) (i32.const 10)) + (func (export "as-set_global-value") (result i32) + (set_global $a (call $const-i32)) + (get_global $a) + ) + (func (export "as-load-operand") (result i32) + (i32.load (call $const-i32)) + ) ) (assert_return (invoke "type-i32") (i32.const 0x132)) @@ -153,6 +244,33 @@ (assert_exhaustion (invoke "runaway") "call stack exhausted") (assert_exhaustion (invoke "mutual-runaway") "call stack exhausted") +(assert_return (invoke "as-select-first") (i32.const 0x132)) +(assert_return (invoke "as-select-mid") (i32.const 2)) +(assert_return (invoke "as-select-last") (i32.const 2)) + +(assert_return (invoke "as-if-condition") (i32.const 1)) + +(assert_return (invoke "as-br_if-first") (i32.const 0x132)) +(assert_return (invoke "as-br_if-last") (i32.const 2)) + +(assert_return (invoke "as-br_table-first") (i32.const 0x132)) +(assert_return (invoke "as-br_table-last") (i32.const 2)) + +(assert_return (invoke "as-call_indirect-first") (i32.const 0x132)) +(assert_return (invoke "as-call_indirect-mid") (i32.const 2)) +(assert_trap (invoke "as-call_indirect-last") "undefined element") + +(assert_return (invoke "as-store-first")) +(assert_return (invoke "as-store-last")) + +;; (assert_return (invoke "as-memory.grow-value") (i32.const 1)) +(assert_return (invoke "as-return-value") (i32.const 0x132)) +(assert_return (invoke "as-drop-operand")) +(assert_return (invoke "as-br-value") (i32.const 0x132)) +(assert_return (invoke "as-set_local-value") (i32.const 0x132)) +(assert_return (invoke "as-tee_local-value") (i32.const 0x132)) +(assert_return (invoke "as-set_global-value") (i32.const 0x132)) +(assert_return (invoke "as-load-operand") (i32.const 1)) ;; Invalid typing diff --git a/spectests/call_indirect.wast b/spectests/call_indirect.wast index 28bdc66f4..c8172db80 100644 --- a/spectests/call_indirect.wast +++ b/spectests/call_indirect.wast @@ -371,6 +371,15 @@ (func (export "as-set_local-value") (result f64) (local f64) (set_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (get_local 0) ) + (func (export "as-tee_local-value") (result f64) + (local f64) (tee_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) + ) + (global $a (mut f64) (f64.const 10.0)) + (func (export "as-set_global-value") (result f64) + (set_global $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7))) + (get_global $a) + ) + (func (export "as-load-operand") (result i32) (i32.load (call_indirect (type $out-i32) (i32.const 0))) ) @@ -508,6 +517,8 @@ (assert_return (invoke "as-drop-operand")) (assert_return (invoke "as-br-value") (f32.const 1)) (assert_return (invoke "as-set_local-value") (f64.const 1)) +(assert_return (invoke "as-tee_local-value") (f64.const 1)) +(assert_return (invoke "as-set_global-value") (f64.const 1.0)) (assert_return (invoke "as-load-operand") (i32.const 1)) ;; Invalid syntax diff --git a/src/integrations/mod.rs b/src/integrations/mod.rs index f0d2436f1..46ba88ce8 100644 --- a/src/integrations/mod.rs +++ b/src/integrations/mod.rs @@ -1,8 +1,14 @@ use crate::webassembly::{ImportObject, VmCtx}; use libc::putchar; +fn printf(format: i32, values: i32, context: &VmCtx) -> i32 { + println!("PRINTF {:?} {:?}", format, values); + return 0; +} + pub fn generate_libc_env<'a, 'b>() -> ImportObject<&'a str, &'b str> { let mut import_object = ImportObject::new(); + import_object.set("env", "printf", printf as *const u8); import_object.set("env", "putchar", putchar as *const u8); import_object } @@ -30,4 +36,20 @@ mod tests { let context = instance.generate_context(); main(&context); } + + // #[test] + // fn test_printf() { + // let wasm_bytes = include_wast2wasm_bytes!("tests/printf.wast"); + // let import_object = generate_libc_env(); + // let result_object = instantiate(wasm_bytes, import_object).expect("Not compiled properly"); + // let module = result_object.module; + // let mut instance = result_object.instance; + // let func_index = match module.info.exports.get("main") { + // Some(&Export::Function(index)) => index, + // _ => panic!("Function not found"), + // }; + // let main: fn(&VmCtx) = get_instance_function!(instance, func_index); + // let context = instance.generate_context(); + // main(&context); + // } } diff --git a/src/spectests/block.rs b/src/spectests/block.rs index de912a6d4..aca254280 100644 --- a/src/spectests/block.rs +++ b/src/spectests/block.rs @@ -315,17 +315,29 @@ fn create_module_1() -> ResultObject { set_local 0 get_local 0) (func (;32;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + end + tee_local 0) + (func (;33;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + end + set_global 0 + get_global 0) + (func (;34;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 1 end i32.load) - (func (;33;) (type 2) (result i32) + (func (;35;) (type 2) (result i32) block (result i32) ;; label = @1 call 0 i32.const 13 end i32.ctz) - (func (;34;) (type 2) (result i32) + (func (;36;) (type 2) (result i32) block (result i32) ;; label = @1 call 0 i32.const 3 @@ -335,13 +347,13 @@ fn create_module_1() -> ResultObject { i32.const 4 end i32.mul) - (func (;35;) (type 2) (result i32) + (func (;37;) (type 2) (result i32) block (result i32) ;; label = @1 call 0 i32.const 13 end i32.eqz) - (func (;36;) (type 2) (result i32) + (func (;38;) (type 2) (result i32) block (result f32) ;; label = @1 call 0 f32.const 0x1.8p+1 (;=3;) @@ -351,7 +363,7 @@ fn create_module_1() -> ResultObject { f32.const 0x1.8p+1 (;=3;) end f32.gt) - (func (;37;) (type 2) (result i32) + (func (;39;) (type 2) (result i32) block ;; label = @1 br 0 (;@1;) unreachable @@ -372,13 +384,13 @@ fn create_module_1() -> ResultObject { unreachable end i32.const 19) - (func (;38;) (type 2) (result i32) + (func (;40;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 18 br 0 (;@1;) i32.const 19 end) - (func (;39;) (type 2) (result i32) + (func (;41;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 18 br 0 (;@1;) @@ -402,7 +414,7 @@ fn create_module_1() -> ResultObject { br_table 0 (;@1;) 0 (;@1;) 0 (;@1;) i32.const 21 end) - (func (;40;) (type 2) (result i32) + (func (;42;) (type 2) (result i32) (local i32) i32.const 0 set_local 0 @@ -443,7 +455,7 @@ fn create_module_1() -> ResultObject { i32.add set_local 0 get_local 0) - (func (;41;) (type 2) (result i32) + (func (;43;) (type 2) (result i32) (local i32) block ;; label = @1 i32.const 1 @@ -471,6 +483,7 @@ fn create_module_1() -> ResultObject { i32.eq) (table (;0;) 1 1 anyfunc) (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) (export \"empty\" (func 1)) (export \"singular\" (func 2)) (export \"multi\" (func 3)) @@ -500,25 +513,27 @@ fn create_module_1() -> ResultObject { (export \"as-drop-operand\" (func 29)) (export \"as-br-value\" (func 30)) (export \"as-set_local-value\" (func 31)) - (export \"as-load-operand\" (func 32)) - (export \"as-unary-operand\" (func 33)) - (export \"as-binary-operand\" (func 34)) - (export \"as-test-operand\" (func 35)) - (export \"as-compare-operand\" (func 36)) - (export \"break-bare\" (func 37)) - (export \"break-value\" (func 38)) - (export \"break-repeated\" (func 39)) - (export \"break-inner\" (func 40)) - (export \"effects\" (func 41)) + (export \"as-tee_local-value\" (func 32)) + (export \"as-set_global-value\" (func 33)) + (export \"as-load-operand\" (func 34)) + (export \"as-unary-operand\" (func 35)) + (export \"as-binary-operand\" (func 36)) + (export \"as-test-operand\" (func 37)) + (export \"as-compare-operand\" (func 38)) + (export \"break-bare\" (func 39)) + (export \"break-value\" (func 40)) + (export \"break-repeated\" (func 41)) + (export \"break-inner\" (func 42)) + (export \"effects\" (func 43)) (elem (i32.const 0) 19)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") } -// Line 243 -fn l243_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l243_assert_return_invoke"); +// Line 252 +fn l252_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l252_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -528,9 +543,9 @@ fn l243_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 244 -fn l244_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l244_assert_return_invoke"); +// Line 253 +fn l253_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l253_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("singular") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -540,9 +555,9 @@ fn l244_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 7 as i32); } -// Line 245 -fn l245_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l245_assert_return_invoke"); +// Line 254 +fn l254_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l254_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multi") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -552,9 +567,9 @@ fn l245_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8 as i32); } -// Line 246 -fn l246_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l246_assert_return_invoke"); +// Line 255 +fn l255_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l255_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -564,9 +579,9 @@ fn l246_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 247 -fn l247_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l247_assert_return_invoke"); +// Line 256 +fn l256_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l256_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("deep") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -576,94 +591,10 @@ fn l247_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 150 as i32); } -// Line 249 -fn l249_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l249_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-select-first") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); -} - -// Line 250 -fn l250_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l250_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-select-mid") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 2 as i32); -} - -// Line 251 -fn l251_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l251_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-select-last") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 2 as i32); -} - -// Line 253 -fn l253_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l253_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-loop-first") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); -} - -// Line 254 -fn l254_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l254_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-loop-mid") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); -} - -// Line 255 -fn l255_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l255_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-loop-last") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); -} - -// Line 257 -fn l257_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l257_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-if-condition") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - // Line 258 fn l258_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l258_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-if-then") { + let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -675,7 +606,7 @@ fn l258_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { // Line 259 fn l259_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l259_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-if-else") { + let func_index = match result_object.module.info.exports.get("as-select-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -684,34 +615,22 @@ fn l259_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 261 -fn l261_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l261_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_if-first") { +// Line 260 +fn l260_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l260_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-select-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); + assert_eq!(result, 2 as i32); } // Line 262 fn l262_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l262_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_if-last") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 2 as i32); -} - -// Line 264 -fn l264_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l264_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_table-first") { + let func_index = match result_object.module.info.exports.get("as-loop-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -720,22 +639,46 @@ fn l264_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 265 -fn l265_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l265_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_table-last") { +// Line 263 +fn l263_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l263_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-loop-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(&vm_context); - assert_eq!(result, 2 as i32); + assert_eq!(result, 1 as i32); +} + +// Line 264 +fn l264_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l264_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-loop-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 266 +fn l266_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l266_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-if-condition") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); } // Line 267 fn l267_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l267_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-call_indirect-first") { + let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -747,7 +690,7 @@ fn l267_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { // Line 268 fn l268_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l268_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-call_indirect-mid") { + let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -756,10 +699,10 @@ fn l268_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 269 -fn l269_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l269_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-call_indirect-last") { +// Line 270 +fn l270_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l270_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_if-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -771,31 +714,19 @@ fn l269_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { // Line 271 fn l271_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l271_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-store-first") { + let func_index = match result_object.module.info.exports.get("as-br_if-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(&vm_context); - assert_eq!(result, ()); + assert_eq!(result, 2 as i32); } -// Line 272 -fn l272_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l272_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-store-last") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 275 -fn l275_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l275_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-call-value") { +// Line 273 +fn l273_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l273_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_table-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -804,10 +735,22 @@ fn l275_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } +// Line 274 +fn l274_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l274_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_table-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + // Line 276 fn l276_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l276_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-return-value") { + let func_index = match result_object.module.info.exports.get("as-call_indirect-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -819,31 +762,19 @@ fn l276_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { // Line 277 fn l277_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l277_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-drop-operand") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 278 -fn l278_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l278_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br-value") { + let func_index = match result_object.module.info.exports.get("as-call_indirect-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); + assert_eq!(result, 2 as i32); } -// Line 279 -fn l279_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l279_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-set_local-value") { +// Line 278 +fn l278_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l278_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-call_indirect-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -855,6 +786,114 @@ fn l279_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { // Line 280 fn l280_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l280_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-store-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 281 +fn l281_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l281_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-store-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 284 +fn l284_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l284_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-call-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 285 +fn l285_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l285_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-return-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 286 +fn l286_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l286_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-drop-operand") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 287 +fn l287_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l287_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 288 +fn l288_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l288_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 289 +fn l289_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l289_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 290 +fn l290_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l290_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 291 +fn l291_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l291_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-load-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -864,9 +903,9 @@ fn l280_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 282 -fn l282_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l282_assert_return_invoke"); +// Line 293 +fn l293_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l293_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-unary-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -876,9 +915,9 @@ fn l282_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 0 as i32); } -// Line 283 -fn l283_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l283_assert_return_invoke"); +// Line 294 +fn l294_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l294_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -888,9 +927,9 @@ fn l283_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 12 as i32); } -// Line 284 -fn l284_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l284_assert_return_invoke"); +// Line 295 +fn l295_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l295_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-test-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -900,9 +939,9 @@ fn l284_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 0 as i32); } -// Line 285 -fn l285_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l285_assert_return_invoke"); +// Line 296 +fn l296_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l296_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-compare-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -912,9 +951,9 @@ fn l285_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 0 as i32); } -// Line 287 -fn l287_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l287_assert_return_invoke"); +// Line 298 +fn l298_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l298_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("break-bare") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -924,9 +963,9 @@ fn l287_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 19 as i32); } -// Line 288 -fn l288_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l288_assert_return_invoke"); +// Line 299 +fn l299_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l299_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("break-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -936,9 +975,9 @@ fn l288_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 18 as i32); } -// Line 289 -fn l289_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l289_assert_return_invoke"); +// Line 300 +fn l300_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l300_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("break-repeated") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -948,9 +987,9 @@ fn l289_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 18 as i32); } -// Line 290 -fn l290_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l290_assert_return_invoke"); +// Line 301 +fn l301_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l301_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("break-inner") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -960,9 +999,9 @@ fn l290_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 15 as i32); } -// Line 292 -fn l292_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l292_assert_return_invoke"); +// Line 303 +fn l303_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l303_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("effects") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -972,1009 +1011,1009 @@ fn l292_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 295 +// Line 306 #[test] -fn l295_assert_invalid() { +fn l306_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 299 +// Line 310 #[test] -fn l299_assert_invalid() { +fn l310_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 303 +// Line 314 #[test] -fn l303_assert_invalid() { +fn l314_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 307 -#[test] -fn l307_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - -// Line 312 -#[test] -fn l312_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 65, 1, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - // Line 318 #[test] fn l318_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 64, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 323 +#[test] +fn l323_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 65, 1, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 329 +#[test] +fn l329_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 64, 66, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 324 +// Line 335 #[test] -fn l324_assert_invalid() { +fn l335_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 67, 0, 0, 128, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 330 +// Line 341 #[test] -fn l330_assert_invalid() { +fn l341_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 337 +// Line 348 #[test] -fn l337_assert_invalid() { +fn l348_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 127, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 343 +// Line 354 #[test] -fn l343_assert_invalid() { +fn l354_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 126, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 349 +// Line 360 #[test] -fn l349_assert_invalid() { +fn l360_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 125, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 355 +// Line 366 #[test] -fn l355_assert_invalid() { +fn l366_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 7, 1, 5, 0, 2, 124, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 362 +// Line 373 #[test] -fn l362_assert_invalid() { +fn l373_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 127, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 368 +// Line 379 #[test] -fn l368_assert_invalid() { +fn l379_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 126, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 374 +// Line 385 #[test] -fn l374_assert_invalid() { +fn l385_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 125, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 380 +// Line 391 #[test] -fn l380_assert_invalid() { +fn l391_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 8, 1, 6, 0, 2, 124, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 387 +// Line 398 #[test] -fn l387_assert_invalid() { +fn l398_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, 66, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 393 +// Line 404 #[test] -fn l393_assert_invalid() { +fn l404_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 67, 0, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 399 +// Line 410 #[test] -fn l399_assert_invalid() { +fn l410_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 405 +// Line 416 #[test] -fn l405_assert_invalid() { +fn l416_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, 65, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 411 +// Line 422 #[test] -fn l411_assert_invalid() { +fn l422_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, 67, 0, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 417 +// Line 428 #[test] -fn l417_assert_invalid() { +fn l428_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 423 +// Line 434 #[test] -fn l423_assert_invalid() { +fn l434_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 65, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 429 +// Line 440 #[test] -fn l429_assert_invalid() { +fn l440_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 66, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 435 +// Line 446 #[test] -fn l435_assert_invalid() { +fn l446_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 441 +// Line 452 #[test] -fn l441_assert_invalid() { +fn l452_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 65, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 447 +// Line 458 #[test] -fn l447_assert_invalid() { +fn l458_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 66, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 453 +// Line 464 #[test] -fn l453_assert_invalid() { +fn l464_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 124, 67, 0, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 460 +// Line 471 #[test] -fn l460_assert_invalid() { +fn l471_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 466 +// Line 477 #[test] -fn l466_assert_invalid() { +fn l477_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 472 +// Line 483 #[test] -fn l472_assert_invalid() { +fn l483_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 478 +// Line 489 #[test] -fn l478_assert_invalid() { +fn l489_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 484 +// Line 495 #[test] -fn l484_assert_invalid() { +fn l495_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 490 +// Line 501 #[test] -fn l490_assert_invalid() { +fn l501_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 496 +// Line 507 #[test] -fn l496_assert_invalid() { +fn l507_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 502 +// Line 513 #[test] -fn l502_assert_invalid() { +fn l513_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 508 +// Line 519 #[test] -fn l508_assert_invalid() { +fn l519_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 124, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 514 +// Line 525 #[test] -fn l514_assert_invalid() { +fn l525_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 520 +// Line 531 #[test] -fn l520_assert_invalid() { +fn l531_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 526 +// Line 537 #[test] -fn l526_assert_invalid() { +fn l537_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 125, 0, 0, 0, 27, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 533 +// Line 544 #[test] -fn l533_assert_invalid() { +fn l544_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 127, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 539 +// Line 550 #[test] -fn l539_assert_invalid() { +fn l550_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 126, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 545 +// Line 556 #[test] -fn l545_assert_invalid() { +fn l556_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 125, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 551 +// Line 562 #[test] -fn l551_assert_invalid() { +fn l562_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 9, 1, 7, 0, 2, 124, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 558 +// Line 569 #[test] -fn l558_assert_invalid() { +fn l569_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 564 +// Line 575 #[test] -fn l564_assert_invalid() { +fn l575_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 126, 12, 0, 66, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 570 +// Line 581 #[test] -fn l570_assert_invalid() { +fn l581_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 125, 12, 0, 67, 0, 0, 128, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 576 +// Line 587 #[test] -fn l576_assert_invalid() { +fn l587_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 124, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 583 +// Line 594 #[test] -fn l583_assert_invalid() { +fn l594_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 1, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 589 +// Line 600 #[test] -fn l589_assert_invalid() { +fn l600_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 126, 1, 12, 0, 66, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 595 +// Line 606 #[test] -fn l595_assert_invalid() { +fn l606_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 125, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 601 +// Line 612 #[test] -fn l601_assert_invalid() { +fn l612_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 124, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 608 +// Line 619 #[test] -fn l608_assert_invalid() { +fn l619_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 66, 1, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 614 +// Line 625 #[test] -fn l614_assert_invalid() { +fn l625_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 67, 0, 0, 128, 63, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 620 +// Line 631 #[test] -fn l620_assert_invalid() { +fn l631_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 626 +// Line 637 #[test] -fn l626_assert_invalid() { +fn l637_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 126, 65, 1, 12, 0, 66, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 632 +// Line 643 #[test] -fn l632_assert_invalid() { +fn l643_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 67, 0, 0, 128, 63, 12, 0, 66, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 638 +// Line 649 #[test] -fn l638_assert_invalid() { +fn l649_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 644 +// Line 655 #[test] -fn l644_assert_invalid() { +fn l655_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 65, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 650 +// Line 661 #[test] -fn l650_assert_invalid() { +fn l661_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 125, 66, 1, 12, 0, 67, 0, 0, 128, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 656 +// Line 667 #[test] -fn l656_assert_invalid() { +fn l667_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 662 +// Line 673 #[test] -fn l662_assert_invalid() { +fn l673_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 126, 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 668 +// Line 679 #[test] -fn l668_assert_invalid() { +fn l679_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 124, 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 674 +// Line 685 #[test] -fn l674_assert_invalid() { +fn l685_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 681 +// Line 692 #[test] -fn l681_assert_invalid() { +fn l692_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 12, 0, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 687 +// Line 698 #[test] -fn l687_assert_invalid() { +fn l698_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 126, 1, 12, 0, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 693 +// Line 704 #[test] -fn l693_assert_invalid() { +fn l704_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 125, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 699 +// Line 710 #[test] -fn l699_assert_invalid() { +fn l710_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 124, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 706 +// Line 717 #[test] -fn l706_assert_invalid() { +fn l717_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 66, 1, 12, 0, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 712 +// Line 723 #[test] -fn l712_assert_invalid() { +fn l723_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 67, 0, 0, 128, 63, 12, 0, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 718 +// Line 729 #[test] -fn l718_assert_invalid() { +fn l729_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 724 +// Line 735 #[test] -fn l724_assert_invalid() { +fn l735_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 126, 65, 1, 12, 0, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 730 +// Line 741 #[test] -fn l730_assert_invalid() { +fn l741_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, 67, 0, 0, 128, 63, 12, 0, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 736 +// Line 747 #[test] -fn l736_assert_invalid() { +fn l747_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 742 +// Line 753 #[test] -fn l742_assert_invalid() { +fn l753_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, 65, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 748 +// Line 759 #[test] -fn l748_assert_invalid() { +fn l759_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 125, 66, 1, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 754 +// Line 765 #[test] -fn l754_assert_invalid() { +fn l765_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 760 +// Line 771 #[test] -fn l760_assert_invalid() { +fn l771_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, 65, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 766 +// Line 777 #[test] -fn l766_assert_invalid() { +fn l777_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 124, 66, 1, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 772 +// Line 783 #[test] -fn l772_assert_invalid() { +fn l783_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 67, 0, 0, 128, 63, 12, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 779 +// Line 790 #[test] -fn l779_assert_invalid() { +fn l790_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, 127, 65, 1, 12, 1, 11, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 785 +// Line 796 #[test] -fn l785_assert_invalid() { +fn l796_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, 126, 66, 1, 12, 1, 11, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 791 +// Line 802 #[test] -fn l791_assert_invalid() { +fn l802_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, 125, 67, 0, 0, 128, 63, 12, 1, 11, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 797 +// Line 808 #[test] -fn l797_assert_invalid() { +fn l808_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, 124, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 804 +// Line 815 #[test] -fn l804_assert_invalid() { +fn l815_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 2, 64, 12, 1, 11, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 810 +// Line 821 #[test] -fn l810_assert_invalid() { +fn l821_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 126, 2, 64, 12, 1, 11, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 816 +// Line 827 #[test] -fn l816_assert_invalid() { +fn l827_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 125, 2, 64, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 822 +// Line 833 #[test] -fn l822_assert_invalid() { +fn l833_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 23, 1, 21, 0, 2, 124, 2, 64, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 829 +// Line 840 #[test] -fn l829_assert_invalid() { +fn l840_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 2, 127, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 835 +// Line 846 #[test] -fn l835_assert_invalid() { +fn l846_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 126, 2, 126, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 841 +// Line 852 #[test] -fn l841_assert_invalid() { +fn l852_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 20, 1, 18, 0, 2, 125, 2, 125, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 847 +// Line 858 #[test] -fn l847_assert_invalid() { +fn l858_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 24, 1, 22, 0, 2, 124, 2, 124, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 854 +// Line 865 #[test] -fn l854_assert_invalid() { +fn l865_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 2, 127, 66, 1, 12, 1, 11, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 862 +// Line 873 #[test] -fn l862_assert_invalid() { +fn l873_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 127, 2, 127, 67, 0, 0, 128, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 870 +// Line 881 #[test] -fn l870_assert_invalid() { +fn l881_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 127, 2, 127, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 65, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 878 +// Line 889 #[test] -fn l878_assert_invalid() { +fn l889_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 126, 2, 126, 65, 1, 12, 1, 11, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 886 +// Line 897 #[test] -fn l886_assert_invalid() { +fn l897_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 126, 2, 126, 67, 0, 0, 128, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 894 +// Line 905 #[test] -fn l894_assert_invalid() { +fn l905_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 126, 2, 126, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 66, 1, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 902 +// Line 913 #[test] -fn l902_assert_invalid() { +fn l913_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, 2, 125, 65, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 910 +// Line 921 #[test] -fn l910_assert_invalid() { +fn l921_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 21, 1, 19, 0, 2, 125, 2, 125, 66, 1, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 918 +// Line 929 #[test] -fn l918_assert_invalid() { +fn l929_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 125, 2, 125, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 1, 11, 67, 0, 0, 128, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 926 +// Line 937 #[test] -fn l926_assert_invalid() { +fn l937_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 2, 124, 65, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 934 +// Line 945 #[test] -fn l934_assert_invalid() { +fn l945_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 25, 1, 23, 0, 2, 124, 2, 124, 66, 1, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 942 +// Line 953 #[test] -fn l942_assert_invalid() { +fn l953_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 28, 1, 26, 0, 2, 124, 2, 124, 67, 0, 0, 128, 63, 12, 1, 11, 68, 0, 0, 0, 0, 0, 0, 240, 63, 12, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 951 +// Line 962 #[test] -fn l951_assert_invalid() { +fn l962_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 104, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 957 +// Line 968 #[test] -fn l957_assert_invalid() { +fn l968_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 122, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 963 +// Line 974 #[test] -fn l963_assert_invalid() { +fn l974_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 142, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 969 +// Line 980 #[test] -fn l969_assert_invalid() { +fn l980_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 12, 0, 11, 156, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 976 +// Line 987 #[test] -fn l976_assert_invalid() { +fn l987_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 104, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 982 +// Line 993 #[test] -fn l982_assert_invalid() { +fn l993_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 122, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 988 +// Line 999 #[test] -fn l988_assert_invalid() { +fn l999_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 142, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 994 +// Line 1005 #[test] -fn l994_assert_invalid() { +fn l1005_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 1, 12, 0, 11, 156, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1001 +// Line 1012 #[test] -fn l1001_assert_invalid() { +fn l1012_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1007 +// Line 1018 #[test] -fn l1007_assert_invalid() { +fn l1018_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1013 +// Line 1024 #[test] -fn l1013_assert_invalid() { +fn l1024_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1019 +// Line 1030 #[test] -fn l1019_assert_invalid() { +fn l1030_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1025 +// Line 1036 #[test] -fn l1025_assert_invalid() { +fn l1036_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1031 +// Line 1042 #[test] -fn l1031_assert_invalid() { +fn l1042_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 126, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1037 +// Line 1048 #[test] -fn l1037_assert_invalid() { +fn l1048_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1043 +// Line 1054 #[test] -fn l1043_assert_invalid() { +fn l1054_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1049 +// Line 1060 #[test] -fn l1049_assert_invalid() { +fn l1060_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 125, 3, 2, 1, 0, 10, 19, 1, 17, 0, 2, 64, 68, 0, 0, 0, 0, 0, 0, 34, 64, 12, 0, 11, 156, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1055 +// Line 1066 #[test] -fn l1055_assert_invalid() { +fn l1066_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 9, 12, 0, 11, 104, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1061 +// Line 1072 #[test] -fn l1061_assert_invalid() { +fn l1072_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 9, 12, 0, 11, 122, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1067 +// Line 1078 #[test] -fn l1067_assert_invalid() { +fn l1078_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 124, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 16, 65, 12, 0, 11, 142, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1074 +// Line 1085 #[test] -fn l1074_assert_malformed() { +fn l1085_assert_malformed() { let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 101, 110, 100, 32, 36, 108, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 1078 +// Line 1089 #[test] -fn l1078_assert_malformed() { +fn l1089_assert_malformed() { let wasm_binary = [40, 102, 117, 110, 99, 32, 98, 108, 111, 99, 107, 32, 36, 97, 32, 101, 110, 100, 32, 36, 108, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); @@ -1985,42 +2024,44 @@ fn test_module_1() { let result_object = create_module_1(); let vm_context = result_object.instance.generate_context(); // We group the calls together - l243_assert_return_invoke(&result_object, &vm_context); - l244_assert_return_invoke(&result_object, &vm_context); - l245_assert_return_invoke(&result_object, &vm_context); - l246_assert_return_invoke(&result_object, &vm_context); - l247_assert_return_invoke(&result_object, &vm_context); - l249_assert_return_invoke(&result_object, &vm_context); - l250_assert_return_invoke(&result_object, &vm_context); - l251_assert_return_invoke(&result_object, &vm_context); + l252_assert_return_invoke(&result_object, &vm_context); l253_assert_return_invoke(&result_object, &vm_context); l254_assert_return_invoke(&result_object, &vm_context); l255_assert_return_invoke(&result_object, &vm_context); - l257_assert_return_invoke(&result_object, &vm_context); + l256_assert_return_invoke(&result_object, &vm_context); l258_assert_return_invoke(&result_object, &vm_context); l259_assert_return_invoke(&result_object, &vm_context); - l261_assert_return_invoke(&result_object, &vm_context); + l260_assert_return_invoke(&result_object, &vm_context); l262_assert_return_invoke(&result_object, &vm_context); + l263_assert_return_invoke(&result_object, &vm_context); l264_assert_return_invoke(&result_object, &vm_context); - l265_assert_return_invoke(&result_object, &vm_context); + l266_assert_return_invoke(&result_object, &vm_context); l267_assert_return_invoke(&result_object, &vm_context); l268_assert_return_invoke(&result_object, &vm_context); - l269_assert_return_invoke(&result_object, &vm_context); + l270_assert_return_invoke(&result_object, &vm_context); l271_assert_return_invoke(&result_object, &vm_context); - l272_assert_return_invoke(&result_object, &vm_context); - l275_assert_return_invoke(&result_object, &vm_context); + l273_assert_return_invoke(&result_object, &vm_context); + l274_assert_return_invoke(&result_object, &vm_context); l276_assert_return_invoke(&result_object, &vm_context); l277_assert_return_invoke(&result_object, &vm_context); l278_assert_return_invoke(&result_object, &vm_context); - l279_assert_return_invoke(&result_object, &vm_context); l280_assert_return_invoke(&result_object, &vm_context); - l282_assert_return_invoke(&result_object, &vm_context); - l283_assert_return_invoke(&result_object, &vm_context); + l281_assert_return_invoke(&result_object, &vm_context); l284_assert_return_invoke(&result_object, &vm_context); l285_assert_return_invoke(&result_object, &vm_context); + l286_assert_return_invoke(&result_object, &vm_context); l287_assert_return_invoke(&result_object, &vm_context); l288_assert_return_invoke(&result_object, &vm_context); l289_assert_return_invoke(&result_object, &vm_context); l290_assert_return_invoke(&result_object, &vm_context); - l292_assert_return_invoke(&result_object, &vm_context); + l291_assert_return_invoke(&result_object, &vm_context); + l293_assert_return_invoke(&result_object, &vm_context); + l294_assert_return_invoke(&result_object, &vm_context); + l295_assert_return_invoke(&result_object, &vm_context); + l296_assert_return_invoke(&result_object, &vm_context); + l298_assert_return_invoke(&result_object, &vm_context); + l299_assert_return_invoke(&result_object, &vm_context); + l300_assert_return_invoke(&result_object, &vm_context); + l301_assert_return_invoke(&result_object, &vm_context); + l303_assert_return_invoke(&result_object, &vm_context); } diff --git a/src/spectests/br.rs b/src/spectests/br.rs index fe21adc32..35e520357 100644 --- a/src/spectests/br.rs +++ b/src/spectests/br.rs @@ -299,19 +299,32 @@ fn create_module_1() -> ResultObject { set_local 0 i32.const -1 end) - (func (;39;) (type 4) (result f32) + (func (;39;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + tee_local 0 + end) + (func (;40;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + br 0 (;@1;) + set_global 0 + end) + (func (;41;) (type 4) (result f32) block (result f32) ;; label = @1 f32.const 0x1.b33334p+0 (;=1.7;) br 0 (;@1;) f32.load end) - (func (;40;) (type 3) (result i64) + (func (;42;) (type 3) (result i64) block (result i64) ;; label = @1 i64.const 30 br 0 (;@1;) i64.load8_s end) - (func (;41;) (type 2) (result i32) + (func (;43;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 30 br 0 (;@1;) @@ -319,7 +332,7 @@ fn create_module_1() -> ResultObject { f64.store i32.const -1 end) - (func (;42;) (type 2) (result i32) + (func (;44;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 2 i32.const 31 @@ -327,7 +340,7 @@ fn create_module_1() -> ResultObject { i64.store i32.const -1 end) - (func (;43;) (type 2) (result i32) + (func (;45;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 32 br 0 (;@1;) @@ -335,7 +348,7 @@ fn create_module_1() -> ResultObject { i32.store8 i32.const -1 end) - (func (;44;) (type 2) (result i32) + (func (;46;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 2 i32.const 33 @@ -343,59 +356,59 @@ fn create_module_1() -> ResultObject { i64.store16 i32.const -1 end) - (func (;45;) (type 4) (result f32) + (func (;47;) (type 4) (result f32) block (result f32) ;; label = @1 f32.const 0x1.b33334p+1 (;=3.4;) br 0 (;@1;) f32.neg end) - (func (;46;) (type 2) (result i32) + (func (;48;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 3 br 0 (;@1;) i32.const 10 i32.add end) - (func (;47;) (type 3) (result i64) + (func (;49;) (type 3) (result i64) block (result i64) ;; label = @1 i64.const 10 i64.const 45 br 0 (;@1;) i64.sub end) - (func (;48;) (type 2) (result i32) + (func (;50;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 44 br 0 (;@1;) i32.eqz end) - (func (;49;) (type 2) (result i32) + (func (;51;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 43 br 0 (;@1;) f64.const 0x1.4p+3 (;=10;) f64.le end) - (func (;50;) (type 2) (result i32) + (func (;52;) (type 2) (result i32) block (result i32) ;; label = @1 f32.const 0x1.4p+3 (;=10;) i32.const 42 br 0 (;@1;) f32.ne end) - (func (;51;) (type 2) (result i32) + (func (;53;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 41 br 0 (;@1;) i32.wrap/i64 end) - (func (;52;) (type 2) (result i32) + (func (;54;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 40 br 0 (;@1;) memory.grow end) - (func (;53;) (type 2) (result i32) + (func (;55;) (type 2) (result i32) i32.const 1 block (result i32) ;; label = @1 call 0 @@ -405,7 +418,7 @@ fn create_module_1() -> ResultObject { i32.add end i32.add) - (func (;54;) (type 2) (result i32) + (func (;56;) (type 2) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -421,7 +434,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;55;) (type 2) (result i32) + (func (;57;) (type 2) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -440,7 +453,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;56;) (type 2) (result i32) + (func (;58;) (type 2) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -453,7 +466,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;57;) (type 2) (result i32) + (func (;59;) (type 2) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -470,7 +483,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;58;) (type 2) (result i32) + (func (;60;) (type 2) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -484,6 +497,7 @@ fn create_module_1() -> ResultObject { i32.add) (table (;0;) 1 1 anyfunc) (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) (export \"type-i32\" (func 1)) (export \"type-i64\" (func 2)) (export \"type-f32\" (func 3)) @@ -521,35 +535,37 @@ fn create_module_1() -> ResultObject { (export \"as-call_indirect-mid\" (func 36)) (export \"as-call_indirect-last\" (func 37)) (export \"as-set_local-value\" (func 38)) - (export \"as-load-address\" (func 39)) - (export \"as-loadN-address\" (func 40)) - (export \"as-store-address\" (func 41)) - (export \"as-store-value\" (func 42)) - (export \"as-storeN-address\" (func 43)) - (export \"as-storeN-value\" (func 44)) - (export \"as-unary-operand\" (func 45)) - (export \"as-binary-left\" (func 46)) - (export \"as-binary-right\" (func 47)) - (export \"as-test-operand\" (func 48)) - (export \"as-compare-left\" (func 49)) - (export \"as-compare-right\" (func 50)) - (export \"as-convert-operand\" (func 51)) - (export \"as-memory.grow-size\" (func 52)) - (export \"nested-block-value\" (func 53)) - (export \"nested-br-value\" (func 54)) - (export \"nested-br_if-value\" (func 55)) - (export \"nested-br_if-value-cond\" (func 56)) - (export \"nested-br_table-value\" (func 57)) - (export \"nested-br_table-value-index\" (func 58)) + (export \"as-tee_local-value\" (func 39)) + (export \"as-set_global-value\" (func 40)) + (export \"as-load-address\" (func 41)) + (export \"as-loadN-address\" (func 42)) + (export \"as-store-address\" (func 43)) + (export \"as-store-value\" (func 44)) + (export \"as-storeN-address\" (func 45)) + (export \"as-storeN-value\" (func 46)) + (export \"as-unary-operand\" (func 47)) + (export \"as-binary-left\" (func 48)) + (export \"as-binary-right\" (func 49)) + (export \"as-test-operand\" (func 50)) + (export \"as-compare-left\" (func 51)) + (export \"as-compare-right\" (func 52)) + (export \"as-convert-operand\" (func 53)) + (export \"as-memory.grow-size\" (func 54)) + (export \"nested-block-value\" (func 55)) + (export \"nested-br-value\" (func 56)) + (export \"nested-br_if-value\" (func 57)) + (export \"nested-br_if-value-cond\" (func 58)) + (export \"nested-br_table-value\" (func 59)) + (export \"nested-br_table-value-index\" (func 60)) (elem (i32.const 0) 30)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") } -// Line 327 -fn l327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l327_assert_return_invoke"); +// Line 334 +fn l334_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l334_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -559,9 +575,9 @@ fn l327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 328 -fn l328_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l328_assert_return_invoke"); +// Line 335 +fn l335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l335_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -571,9 +587,9 @@ fn l328_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 329 -fn l329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l329_assert_return_invoke"); +// Line 336 +fn l336_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l336_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -583,82 +599,10 @@ fn l329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 330 -fn l330_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l330_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("type-f64") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 332 -fn l332_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l332_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("type-i32-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 1 as i32); -} - -// Line 333 -fn l333_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l333_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("type-i64-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i64 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 2 as i64); -} - -// Line 334 -fn l334_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l334_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("type-f32-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 3.0 as f32); -} - -// Line 335 -fn l335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l335_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("type-f64-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 4.0 as f64); -} - // Line 337 fn l337_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l337_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-block-first") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 338 -fn l338_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l338_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-block-mid") { + let func_index = match result_object.module.info.exports.get("type-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -670,6 +614,78 @@ fn l338_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { // Line 339 fn l339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l339_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("type-i32-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 340 +fn l340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l340_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("type-i64-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i64); +} + +// Line 341 +fn l341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l341_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("type-f32-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> f32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 3.0 as f32); +} + +// Line 342 +fn l342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l342_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("type-f64-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 4.0 as f64); +} + +// Line 344 +fn l344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l344_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-block-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 345 +fn l345_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l345_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-block-mid") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 346 +fn l346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l346_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -679,9 +695,9 @@ fn l339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 340 -fn l340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l340_assert_return_invoke"); +// Line 347 +fn l347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l347_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -691,9 +707,9 @@ fn l340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 342 -fn l342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l342_assert_return_invoke"); +// Line 349 +fn l349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l349_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -703,9 +719,9 @@ fn l342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 343 -fn l343_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l343_assert_return_invoke"); +// Line 350 +fn l350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l350_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -715,9 +731,9 @@ fn l343_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 344 -fn l344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l344_assert_return_invoke"); +// Line 351 +fn l351_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l351_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -727,9 +743,9 @@ fn l344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 346 -fn l346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l346_assert_return_invoke"); +// Line 353 +fn l353_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l353_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -739,9 +755,9 @@ fn l346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 348 -fn l348_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l348_assert_return_invoke"); +// Line 355 +fn l355_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l355_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -751,9 +767,9 @@ fn l348_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 349 -fn l349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l349_assert_return_invoke"); +// Line 356 +fn l356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l356_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -763,9 +779,9 @@ fn l349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8 as i32); } -// Line 350 -fn l350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l350_assert_return_invoke"); +// Line 357 +fn l357_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l357_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-value-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -775,9 +791,9 @@ fn l350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 352 -fn l352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l352_assert_return_invoke"); +// Line 359 +fn l359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l359_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -787,9 +803,9 @@ fn l352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 353 -fn l353_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l353_assert_return_invoke"); +// Line 360 +fn l360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l360_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -799,9 +815,9 @@ fn l353_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10 as i32); } -// Line 354 -fn l354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l354_assert_return_invoke"); +// Line 361 +fn l361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l361_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -811,9 +827,9 @@ fn l354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 11 as i32); } -// Line 356 -fn l356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l356_assert_return_invoke"); +// Line 363 +fn l363_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l363_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-return-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -823,9 +839,9 @@ fn l356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 7 as i64); } -// Line 358 -fn l358_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l358_assert_return_invoke"); +// Line 365 +fn l365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l365_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -835,9 +851,9 @@ fn l358_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 359 -fn l359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l359_assert_return_invoke"); +// Line 366 +fn l366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l366_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -847,9 +863,9 @@ fn l359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 360 -fn l360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l360_assert_return_invoke"); +// Line 367 +fn l367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l367_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -859,9 +875,9 @@ fn l360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 6 as i32); } -// Line 361 -fn l361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l361_assert_return_invoke"); +// Line 368 +fn l368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l368_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -871,9 +887,9 @@ fn l361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 362 -fn l362_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l362_assert_return_invoke"); +// Line 369 +fn l369_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l369_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -883,9 +899,9 @@ fn l362_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 6 as i32); } -// Line 364 -fn l364_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l364_assert_return_invoke"); +// Line 371 +fn l371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l371_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -895,9 +911,9 @@ fn l364_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 365 -fn l365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l365_assert_return_invoke"); +// Line 372 +fn l372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l372_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -907,9 +923,9 @@ fn l365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 366 -fn l366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l366_assert_return_invoke"); +// Line 373 +fn l373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l373_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-second") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -919,9 +935,9 @@ fn l366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 6 as i32); } -// Line 367 -fn l367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l367_assert_return_invoke"); +// Line 374 +fn l374_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l374_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-second") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -931,9 +947,9 @@ fn l367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 6 as i32); } -// Line 368 -fn l368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l368_assert_return_invoke"); +// Line 375 +fn l375_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l375_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -943,9 +959,9 @@ fn l368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 7 as i32); } -// Line 370 -fn l370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l370_assert_return_invoke"); +// Line 377 +fn l377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l377_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -955,9 +971,9 @@ fn l370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 12 as i32); } -// Line 371 -fn l371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l371_assert_return_invoke"); +// Line 378 +fn l378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l378_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -967,9 +983,9 @@ fn l371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 13 as i32); } -// Line 372 -fn l372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l372_assert_return_invoke"); +// Line 379 +fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l379_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -979,9 +995,9 @@ fn l372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 14 as i32); } -// Line 374 -fn l374_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l374_assert_return_invoke"); +// Line 381 +fn l381_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l381_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-func") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -991,9 +1007,9 @@ fn l374_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 20 as i32); } -// Line 375 -fn l375_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l375_assert_return_invoke"); +// Line 382 +fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l382_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1003,9 +1019,9 @@ fn l375_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 21 as i32); } -// Line 376 -fn l376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l376_assert_return_invoke"); +// Line 383 +fn l383_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l383_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1015,9 +1031,9 @@ fn l376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 22 as i32); } -// Line 377 -fn l377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l377_assert_return_invoke"); +// Line 384 +fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l384_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1027,9 +1043,9 @@ fn l377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 23 as i32); } -// Line 379 -fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l379_assert_return_invoke"); +// Line 386 +fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l386_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-set_local-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1039,9 +1055,33 @@ fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 17 as i32); } -// Line 381 -fn l381_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l381_assert_return_invoke"); +// Line 387 +fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l387_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 388 +fn l388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l388_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 390 +fn l390_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l390_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-load-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1051,9 +1091,9 @@ fn l381_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.7 as f32); } -// Line 382 -fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l382_assert_return_invoke"); +// Line 391 +fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l391_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loadN-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1063,9 +1103,9 @@ fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 30 as i64); } -// Line 384 -fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l384_assert_return_invoke"); +// Line 393 +fn l393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l393_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-store-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1075,9 +1115,9 @@ fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 30 as i32); } -// Line 385 -fn l385_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l385_assert_return_invoke"); +// Line 394 +fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l394_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-store-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1087,9 +1127,9 @@ fn l385_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 31 as i32); } -// Line 386 -fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l386_assert_return_invoke"); +// Line 395 +fn l395_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l395_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-storeN-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1099,9 +1139,9 @@ fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32 as i32); } -// Line 387 -fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l387_assert_return_invoke"); +// Line 396 +fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l396_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-storeN-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1111,9 +1151,9 @@ fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 33 as i32); } -// Line 389 -fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l389_assert_return_invoke"); +// Line 398 +fn l398_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l398_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-unary-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1123,9 +1163,9 @@ fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3.4 as f32); } -// Line 391 -fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l391_assert_return_invoke"); +// Line 400 +fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l400_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-left") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1135,9 +1175,9 @@ fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 392 -fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l392_assert_return_invoke"); +// Line 401 +fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l401_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-right") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1147,9 +1187,9 @@ fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 45 as i64); } -// Line 394 -fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l394_assert_return_invoke"); +// Line 403 +fn l403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l403_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-test-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1159,9 +1199,9 @@ fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 396 -fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l396_assert_return_invoke"); +// Line 405 +fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l405_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-compare-left") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1171,9 +1211,9 @@ fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 43 as i32); } -// Line 397 -fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l397_assert_return_invoke"); +// Line 406 +fn l406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l406_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-compare-right") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1183,9 +1223,9 @@ fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 42 as i32); } -// Line 399 -fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l399_assert_return_invoke"); +// Line 408 +fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l408_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-convert-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1195,9 +1235,9 @@ fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 41 as i32); } -// Line 401 -fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l401_assert_return_invoke"); +// Line 410 +fn l410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l410_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-memory.grow-size") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1207,9 +1247,9 @@ fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 40 as i32); } -// Line 403 -fn l403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l403_assert_return_invoke"); +// Line 412 +fn l412_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l412_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1219,9 +1259,9 @@ fn l403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 404 -fn l404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l404_assert_return_invoke"); +// Line 413 +fn l413_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l413_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1231,9 +1271,9 @@ fn l404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 405 -fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l405_assert_return_invoke"); +// Line 414 +fn l414_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l414_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1243,9 +1283,9 @@ fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 406 -fn l406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l406_assert_return_invoke"); +// Line 415 +fn l415_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l415_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1255,9 +1295,9 @@ fn l406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 407 -fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l407_assert_return_invoke"); +// Line 416 +fn l416_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l416_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1267,9 +1307,9 @@ fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 408 -fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l408_assert_return_invoke"); +// Line 417 +fn l417_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l417_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1279,57 +1319,57 @@ fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 411 +// Line 420 #[test] -fn l411_assert_invalid() { +fn l420_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 127, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 418 +// Line 427 #[test] -fn l418_assert_invalid() { +fn l427_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 127, 1, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 424 +// Line 433 #[test] -fn l424_assert_invalid() { +fn l433_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 2, 64, 12, 1, 11, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 430 +// Line 439 #[test] -fn l430_assert_invalid() { +fn l439_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 66, 1, 12, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 437 +// Line 446 #[test] -fn l437_assert_invalid() { +fn l446_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 12, 1, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 441 +// Line 450 #[test] -fn l441_assert_invalid() { +fn l450_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 2, 64, 12, 5, 11, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 445 +// Line 454 #[test] -fn l445_assert_invalid() { +fn l454_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 12, 129, 128, 128, 128, 1, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); @@ -1340,65 +1380,67 @@ fn test_module_1() { let result_object = create_module_1(); let vm_context = result_object.instance.generate_context(); // We group the calls together - l327_assert_return_invoke(&result_object, &vm_context); - l328_assert_return_invoke(&result_object, &vm_context); - l329_assert_return_invoke(&result_object, &vm_context); - l330_assert_return_invoke(&result_object, &vm_context); - l332_assert_return_invoke(&result_object, &vm_context); - l333_assert_return_invoke(&result_object, &vm_context); l334_assert_return_invoke(&result_object, &vm_context); l335_assert_return_invoke(&result_object, &vm_context); + l336_assert_return_invoke(&result_object, &vm_context); l337_assert_return_invoke(&result_object, &vm_context); - l338_assert_return_invoke(&result_object, &vm_context); l339_assert_return_invoke(&result_object, &vm_context); l340_assert_return_invoke(&result_object, &vm_context); + l341_assert_return_invoke(&result_object, &vm_context); l342_assert_return_invoke(&result_object, &vm_context); - l343_assert_return_invoke(&result_object, &vm_context); l344_assert_return_invoke(&result_object, &vm_context); + l345_assert_return_invoke(&result_object, &vm_context); l346_assert_return_invoke(&result_object, &vm_context); - l348_assert_return_invoke(&result_object, &vm_context); + l347_assert_return_invoke(&result_object, &vm_context); l349_assert_return_invoke(&result_object, &vm_context); l350_assert_return_invoke(&result_object, &vm_context); - l352_assert_return_invoke(&result_object, &vm_context); + l351_assert_return_invoke(&result_object, &vm_context); l353_assert_return_invoke(&result_object, &vm_context); - l354_assert_return_invoke(&result_object, &vm_context); + l355_assert_return_invoke(&result_object, &vm_context); l356_assert_return_invoke(&result_object, &vm_context); - l358_assert_return_invoke(&result_object, &vm_context); + l357_assert_return_invoke(&result_object, &vm_context); l359_assert_return_invoke(&result_object, &vm_context); l360_assert_return_invoke(&result_object, &vm_context); l361_assert_return_invoke(&result_object, &vm_context); - l362_assert_return_invoke(&result_object, &vm_context); - l364_assert_return_invoke(&result_object, &vm_context); + l363_assert_return_invoke(&result_object, &vm_context); l365_assert_return_invoke(&result_object, &vm_context); l366_assert_return_invoke(&result_object, &vm_context); l367_assert_return_invoke(&result_object, &vm_context); l368_assert_return_invoke(&result_object, &vm_context); - l370_assert_return_invoke(&result_object, &vm_context); + l369_assert_return_invoke(&result_object, &vm_context); l371_assert_return_invoke(&result_object, &vm_context); l372_assert_return_invoke(&result_object, &vm_context); + l373_assert_return_invoke(&result_object, &vm_context); l374_assert_return_invoke(&result_object, &vm_context); l375_assert_return_invoke(&result_object, &vm_context); - l376_assert_return_invoke(&result_object, &vm_context); l377_assert_return_invoke(&result_object, &vm_context); + l378_assert_return_invoke(&result_object, &vm_context); l379_assert_return_invoke(&result_object, &vm_context); l381_assert_return_invoke(&result_object, &vm_context); l382_assert_return_invoke(&result_object, &vm_context); + l383_assert_return_invoke(&result_object, &vm_context); l384_assert_return_invoke(&result_object, &vm_context); - l385_assert_return_invoke(&result_object, &vm_context); l386_assert_return_invoke(&result_object, &vm_context); l387_assert_return_invoke(&result_object, &vm_context); - l389_assert_return_invoke(&result_object, &vm_context); + l388_assert_return_invoke(&result_object, &vm_context); + l390_assert_return_invoke(&result_object, &vm_context); l391_assert_return_invoke(&result_object, &vm_context); - l392_assert_return_invoke(&result_object, &vm_context); + l393_assert_return_invoke(&result_object, &vm_context); l394_assert_return_invoke(&result_object, &vm_context); + l395_assert_return_invoke(&result_object, &vm_context); l396_assert_return_invoke(&result_object, &vm_context); - l397_assert_return_invoke(&result_object, &vm_context); - l399_assert_return_invoke(&result_object, &vm_context); + l398_assert_return_invoke(&result_object, &vm_context); + l400_assert_return_invoke(&result_object, &vm_context); l401_assert_return_invoke(&result_object, &vm_context); l403_assert_return_invoke(&result_object, &vm_context); - l404_assert_return_invoke(&result_object, &vm_context); l405_assert_return_invoke(&result_object, &vm_context); l406_assert_return_invoke(&result_object, &vm_context); - l407_assert_return_invoke(&result_object, &vm_context); l408_assert_return_invoke(&result_object, &vm_context); + l410_assert_return_invoke(&result_object, &vm_context); + l412_assert_return_invoke(&result_object, &vm_context); + l413_assert_return_invoke(&result_object, &vm_context); + l414_assert_return_invoke(&result_object, &vm_context); + l415_assert_return_invoke(&result_object, &vm_context); + l416_assert_return_invoke(&result_object, &vm_context); + l417_assert_return_invoke(&result_object, &vm_context); } diff --git a/src/spectests/br_if.rs b/src/spectests/br_if.rs index 666e63209..e76a7ed8d 100644 --- a/src/spectests/br_if.rs +++ b/src/spectests/br_if.rs @@ -365,14 +365,32 @@ fn create_module_1() -> ResultObject { set_local 0 i32.const -1 end) - (func (;42;) (type 5) (result f64) + (func (;42;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + get_local 0 + br_if 0 (;@1;) + tee_local 0 + i32.const -1 + return + end) + (func (;43;) (type 6) (param i32) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + get_local 0 + br_if 0 (;@1;) + set_global 0 + i32.const -1 + return + end) + (func (;44;) (type 5) (result f64) block (result f64) ;; label = @1 f64.const 0x1p+0 (;=1;) i32.const 1 br_if 0 (;@1;) f64.neg end) - (func (;43;) (type 2) (result i32) + (func (;45;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 1 i32.const 1 @@ -380,7 +398,7 @@ fn create_module_1() -> ResultObject { i32.const 10 i32.add end) - (func (;44;) (type 2) (result i32) + (func (;46;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 10 i32.const 1 @@ -388,14 +406,14 @@ fn create_module_1() -> ResultObject { br_if 0 (;@1;) i32.sub end) - (func (;45;) (type 2) (result i32) + (func (;47;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 1 i32.const 1 br_if 0 (;@1;) memory.grow end) - (func (;46;) (type 6) (param i32) (result i32) + (func (;48;) (type 6) (param i32) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -411,7 +429,7 @@ fn create_module_1() -> ResultObject { i32.add end i32.add) - (func (;47;) (type 6) (param i32) (result i32) + (func (;49;) (type 6) (param i32) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -427,7 +445,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;48;) (type 6) (param i32) (result i32) + (func (;50;) (type 6) (param i32) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -445,7 +463,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;49;) (type 6) (param i32) (result i32) + (func (;51;) (type 6) (param i32) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -463,7 +481,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;50;) (type 6) (param i32) (result i32) + (func (;52;) (type 6) (param i32) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -480,7 +498,7 @@ fn create_module_1() -> ResultObject { i32.const 16 end i32.add) - (func (;51;) (type 6) (param i32) (result i32) + (func (;53;) (type 6) (param i32) (result i32) i32.const 1 block (result i32) ;; label = @1 i32.const 2 @@ -499,6 +517,7 @@ fn create_module_1() -> ResultObject { i32.add) (table (;0;) 1 1 anyfunc) (memory (;0;) 0) + (global (;0;) (mut i32) (i32.const 10)) (export \"type-i32\" (func 1)) (export \"type-i64\" (func 2)) (export \"type-f32\" (func 3)) @@ -538,25 +557,27 @@ fn create_module_1() -> ResultObject { (export \"as-call_indirect-mid\" (func 39)) (export \"as-call_indirect-last\" (func 40)) (export \"as-set_local-value\" (func 41)) - (export \"as-unary-operand\" (func 42)) - (export \"as-binary-left\" (func 43)) - (export \"as-binary-right\" (func 44)) - (export \"as-memory.grow-size\" (func 45)) - (export \"nested-block-value\" (func 46)) - (export \"nested-br-value\" (func 47)) - (export \"nested-br_if-value\" (func 48)) - (export \"nested-br_if-value-cond\" (func 49)) - (export \"nested-br_table-value\" (func 50)) - (export \"nested-br_table-value-index\" (func 51)) + (export \"as-tee_local-value\" (func 42)) + (export \"as-set_global-value\" (func 43)) + (export \"as-unary-operand\" (func 44)) + (export \"as-binary-left\" (func 45)) + (export \"as-binary-right\" (func 46)) + (export \"as-memory.grow-size\" (func 47)) + (export \"nested-block-value\" (func 48)) + (export \"nested-br-value\" (func 49)) + (export \"nested-br_if-value\" (func 50)) + (export \"nested-br_if-value-cond\" (func 51)) + (export \"nested-br_table-value\" (func 52)) + (export \"nested-br_table-value-index\" (func 53)) (elem (i32.const 0) 36)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") } -// Line 321 -fn l321_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l321_assert_return_invoke"); +// Line 334 +fn l334_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l334_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -566,9 +587,9 @@ fn l321_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 322 -fn l322_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l322_assert_return_invoke"); +// Line 335 +fn l335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l335_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -578,9 +599,9 @@ fn l322_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 323 -fn l323_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l323_assert_return_invoke"); +// Line 336 +fn l336_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l336_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -590,9 +611,9 @@ fn l323_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 324 -fn l324_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l324_assert_return_invoke"); +// Line 337 +fn l337_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l337_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -602,9 +623,9 @@ fn l324_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 326 -fn l326_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l326_assert_return_invoke"); +// Line 339 +fn l339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l339_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -614,9 +635,9 @@ fn l326_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 327 -fn l327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l327_assert_return_invoke"); +// Line 340 +fn l340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l340_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -626,9 +647,9 @@ fn l327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i64); } -// Line 328 -fn l328_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l328_assert_return_invoke"); +// Line 341 +fn l341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l341_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -638,9 +659,9 @@ fn l328_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3.0 as f32); } -// Line 329 -fn l329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l329_assert_return_invoke"); +// Line 342 +fn l342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l342_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f64-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -650,9 +671,9 @@ fn l329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4.0 as f64); } -// Line 331 -fn l331_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l331_assert_return_invoke"); +// Line 344 +fn l344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l344_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -662,9 +683,9 @@ fn l331_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 332 -fn l332_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l332_assert_return_invoke"); +// Line 345 +fn l345_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l345_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -674,9 +695,9 @@ fn l332_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 333 -fn l333_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l333_assert_return_invoke"); +// Line 346 +fn l346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l346_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -686,9 +707,9 @@ fn l333_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 334 -fn l334_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l334_assert_return_invoke"); +// Line 347 +fn l347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l347_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -698,9 +719,9 @@ fn l334_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 335 -fn l335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l335_assert_return_invoke"); +// Line 348 +fn l348_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l348_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -710,9 +731,9 @@ fn l335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 336 -fn l336_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l336_assert_return_invoke"); +// Line 349 +fn l349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l349_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -722,9 +743,9 @@ fn l336_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 338 -fn l338_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l338_assert_return_invoke"); +// Line 351 +fn l351_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l351_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-first-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -734,9 +755,9 @@ fn l338_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 11 as i32); } -// Line 339 -fn l339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l339_assert_return_invoke"); +// Line 352 +fn l352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l352_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-first-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -746,9 +767,9 @@ fn l339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10 as i32); } -// Line 340 -fn l340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l340_assert_return_invoke"); +// Line 353 +fn l353_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l353_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-mid-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -758,9 +779,9 @@ fn l340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 21 as i32); } -// Line 341 -fn l341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l341_assert_return_invoke"); +// Line 354 +fn l354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l354_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-mid-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -770,9 +791,9 @@ fn l341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 20 as i32); } -// Line 342 -fn l342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l342_assert_return_invoke"); +// Line 355 +fn l355_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l355_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-last-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -782,9 +803,9 @@ fn l342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 11 as i32); } -// Line 343 -fn l343_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l343_assert_return_invoke"); +// Line 356 +fn l356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l356_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-last-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -794,9 +815,9 @@ fn l343_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 11 as i32); } -// Line 345 -fn l345_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l345_assert_return_invoke"); +// Line 358 +fn l358_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l358_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -806,9 +827,9 @@ fn l345_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 346 -fn l346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l346_assert_return_invoke"); +// Line 359 +fn l359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l359_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -818,9 +839,9 @@ fn l346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 347 -fn l347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l347_assert_return_invoke"); +// Line 360 +fn l360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l360_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -830,9 +851,9 @@ fn l347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 348 -fn l348_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l348_assert_return_invoke"); +// Line 361 +fn l361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l361_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -842,9 +863,9 @@ fn l348_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 349 -fn l349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l349_assert_return_invoke"); +// Line 362 +fn l362_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l362_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -854,9 +875,9 @@ fn l349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 350 -fn l350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l350_assert_return_invoke"); +// Line 363 +fn l363_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l363_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loop-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -866,9 +887,9 @@ fn l350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 352 -fn l352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l352_assert_return_invoke"); +// Line 365 +fn l365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l365_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -878,9 +899,9 @@ fn l352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 354 -fn l354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l354_assert_return_invoke"); +// Line 367 +fn l367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l367_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -890,9 +911,9 @@ fn l354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 355 -fn l355_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l355_assert_return_invoke"); +// Line 368 +fn l368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l368_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -902,9 +923,9 @@ fn l355_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 356 -fn l356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l356_assert_return_invoke"); +// Line 369 +fn l369_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l369_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-value-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -914,9 +935,9 @@ fn l356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 357 -fn l357_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l357_assert_return_invoke"); +// Line 370 +fn l370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l370_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-value-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -926,9 +947,9 @@ fn l357_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 359 -fn l359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l359_assert_return_invoke"); +// Line 372 +fn l372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l372_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -938,9 +959,9 @@ fn l359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 360 -fn l360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l360_assert_return_invoke"); +// Line 373 +fn l373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l373_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -950,9 +971,9 @@ fn l360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 361 -fn l361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l361_assert_return_invoke"); +// Line 374 +fn l374_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l374_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -962,9 +983,9 @@ fn l361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 363 -fn l363_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l363_assert_return_invoke"); +// Line 376 +fn l376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l376_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-return-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -974,9 +995,9 @@ fn l363_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 365 -fn l365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l365_assert_return_invoke"); +// Line 378 +fn l378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l378_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -986,9 +1007,9 @@ fn l365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 366 -fn l366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l366_assert_return_invoke"); +// Line 379 +fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l379_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -998,9 +1019,9 @@ fn l366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 367 -fn l367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l367_assert_return_invoke"); +// Line 380 +fn l380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l380_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1010,9 +1031,9 @@ fn l367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 368 -fn l368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l368_assert_return_invoke"); +// Line 381 +fn l381_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l381_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1022,9 +1043,9 @@ fn l368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 369 -fn l369_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l369_assert_return_invoke"); +// Line 382 +fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l382_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1034,9 +1055,9 @@ fn l369_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 370 -fn l370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l370_assert_return_invoke"); +// Line 383 +fn l383_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l383_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1046,9 +1067,9 @@ fn l370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 371 -fn l371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l371_assert_return_invoke"); +// Line 384 +fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l384_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1058,9 +1079,9 @@ fn l371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 372 -fn l372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l372_assert_return_invoke"); +// Line 385 +fn l385_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l385_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1070,9 +1091,9 @@ fn l372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 373 -fn l373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l373_assert_return_invoke"); +// Line 386 +fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l386_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1082,9 +1103,9 @@ fn l373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 374 -fn l374_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l374_assert_return_invoke"); +// Line 387 +fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l387_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1094,9 +1115,9 @@ fn l374_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 376 -fn l376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l376_assert_return_invoke"); +// Line 389 +fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l389_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1106,9 +1127,9 @@ fn l376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 377 -fn l377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l377_assert_return_invoke"); +// Line 390 +fn l390_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l390_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1118,9 +1139,9 @@ fn l377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 378 -fn l378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l378_assert_return_invoke"); +// Line 391 +fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l391_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-second") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1130,9 +1151,9 @@ fn l378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 379 -fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l379_assert_return_invoke"); +// Line 392 +fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l392_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-second") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1142,9 +1163,9 @@ fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 380 -fn l380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l380_assert_return_invoke"); +// Line 393 +fn l393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l393_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1154,9 +1175,9 @@ fn l380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3 as i32); } -// Line 382 -fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l382_assert_return_invoke"); +// Line 395 +fn l395_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l395_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1166,9 +1187,9 @@ fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 12 as i32); } -// Line 383 -fn l383_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l383_assert_return_invoke"); +// Line 396 +fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l396_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1178,9 +1199,9 @@ fn l383_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 13 as i32); } -// Line 384 -fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l384_assert_return_invoke"); +// Line 397 +fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l397_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1190,9 +1211,9 @@ fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 14 as i32); } -// Line 386 -fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l386_assert_return_invoke"); +// Line 399 +fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l399_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-func") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1202,9 +1223,9 @@ fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 387 -fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l387_assert_return_invoke"); +// Line 400 +fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l400_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1214,9 +1235,9 @@ fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 388 -fn l388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l388_assert_return_invoke"); +// Line 401 +fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l401_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1226,9 +1247,9 @@ fn l388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 389 -fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l389_assert_return_invoke"); +// Line 402 +fn l402_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l402_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1238,9 +1259,9 @@ fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 4 as i32); } -// Line 391 -fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l391_assert_return_invoke"); +// Line 404 +fn l404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l404_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-set_local-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1250,9 +1271,9 @@ fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, -1 as i32); } -// Line 392 -fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l392_assert_return_invoke"); +// Line 405 +fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l405_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-set_local-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1262,9 +1283,57 @@ fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 17 as i32); } -// Line 394 -fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l394_assert_return_invoke"); +// Line 407 +fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l407_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, -1 as i32); +} + +// Line 408 +fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l408_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 410 +fn l410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l410_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, -1 as i32); +} + +// Line 411 +fn l411_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l411_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 413 +fn l413_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l413_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-unary-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1274,9 +1343,9 @@ fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f64); } -// Line 395 -fn l395_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l395_assert_return_invoke"); +// Line 414 +fn l414_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l414_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-left") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1286,9 +1355,9 @@ fn l395_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 396 -fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l396_assert_return_invoke"); +// Line 415 +fn l415_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l415_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-right") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1298,9 +1367,9 @@ fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 397 -fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l397_assert_return_invoke"); +// Line 416 +fn l416_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l416_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-memory.grow-size") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1310,9 +1379,9 @@ fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 399 -fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l399_assert_return_invoke"); +// Line 418 +fn l418_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l418_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1322,9 +1391,9 @@ fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 21 as i32); } -// Line 400 -fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l400_assert_return_invoke"); +// Line 419 +fn l419_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l419_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1334,9 +1403,9 @@ fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 401 -fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l401_assert_return_invoke"); +// Line 420 +fn l420_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l420_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1346,9 +1415,9 @@ fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 402 -fn l402_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l402_assert_return_invoke"); +// Line 421 +fn l421_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l421_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1358,9 +1427,9 @@ fn l402_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 403 -fn l403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l403_assert_return_invoke"); +// Line 422 +fn l422_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l422_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1370,9 +1439,9 @@ fn l403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 404 -fn l404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l404_assert_return_invoke"); +// Line 423 +fn l423_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l423_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1382,9 +1451,9 @@ fn l404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 405 -fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l405_assert_return_invoke"); +// Line 424 +fn l424_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l424_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1394,9 +1463,9 @@ fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 406 -fn l406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l406_assert_return_invoke"); +// Line 425 +fn l425_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l425_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1406,9 +1475,9 @@ fn l406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 407 -fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l407_assert_return_invoke"); +// Line 426 +fn l426_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l426_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1418,9 +1487,9 @@ fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 408 -fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l408_assert_return_invoke"); +// Line 427 +fn l427_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l427_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1430,9 +1499,9 @@ fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 409 -fn l409_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l409_assert_return_invoke"); +// Line 428 +fn l428_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l428_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1442,9 +1511,9 @@ fn l409_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i32); } -// Line 410 -fn l410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l410_assert_return_invoke"); +// Line 429 +fn l429_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l429_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1454,98 +1523,74 @@ fn l410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 413 +// Line 432 #[test] -fn l413_assert_invalid() { +fn l432_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 104, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 417 +// Line 436 #[test] -fn l417_assert_invalid() { +fn l436_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 122, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 421 +// Line 440 #[test] -fn l421_assert_invalid() { +fn l440_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 140, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 425 +// Line 444 #[test] -fn l425_assert_invalid() { +fn l444_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 0, 13, 0, 154, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 430 +// Line 449 #[test] -fn l430_assert_invalid() { +fn l449_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 65, 1, 13, 0, 104, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 434 -#[test] -fn l434_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 122, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - -// Line 438 -#[test] -fn l438_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 128, 63, 13, 0, 140, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - -// Line 442 -#[test] -fn l442_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 154, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - -// Line 447 -#[test] -fn l447_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 0, 13, 0, 65, 1, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - // Line 453 #[test] fn l453_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 1, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 122, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 459 +// Line 457 #[test] -fn l459_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 0, 13, 0, 11, 11]; +fn l457_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 64, 67, 0, 0, 128, 63, 13, 0, 140, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 465 +// Line 461 #[test] -fn l465_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 1, 13, 0, 11, 11]; +fn l461_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 1, 13, 0, 154, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 466 +#[test] +fn l466_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 0, 13, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } @@ -1553,7 +1598,7 @@ fn l465_assert_invalid() { // Line 472 #[test] fn l472_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 0, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 127, 65, 1, 13, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } @@ -1561,7 +1606,7 @@ fn l472_assert_invalid() { // Line 478 #[test] fn l478_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 1, 13, 0, 65, 1, 11, 11]; + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 0, 13, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } @@ -1569,78 +1614,102 @@ fn l478_assert_invalid() { // Line 484 #[test] fn l484_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 0, 65, 1, 13, 0, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 491 +#[test] +fn l491_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 0, 13, 0, 65, 1, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 497 +#[test] +fn l497_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 1, 65, 1, 13, 0, 65, 1, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 503 +#[test] +fn l503_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 492 +// Line 511 #[test] -fn l492_assert_invalid() { +fn l511_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 66, 1, 65, 0, 13, 0, 26, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 501 +// Line 520 #[test] -fn l501_assert_invalid() { +fn l520_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 2, 64, 1, 13, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 507 +// Line 526 #[test] -fn l507_assert_invalid() { +fn l526_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 11, 1, 9, 0, 2, 64, 66, 0, 13, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 513 -#[test] -fn l513_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 1, 13, 0, 65, 1, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - -// Line 519 -#[test] -fn l519_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 2, 64, 65, 1, 13, 1, 11, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - -// Line 525 -#[test] -fn l525_assert_invalid() { - let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 65, 0, 66, 0, 13, 0, 65, 1, 11, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - // Line 532 #[test] fn l532_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 127, 65, 0, 1, 13, 0, 65, 1, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 538 +#[test] +fn l538_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 2, 64, 65, 1, 13, 1, 11, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 544 +#[test] +fn l544_assert_invalid() { + let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 65, 0, 66, 0, 13, 0, 65, 1, 11, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 551 +#[test] +fn l551_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 8, 1, 6, 0, 65, 1, 13, 1, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 536 +// Line 555 #[test] -fn l536_assert_invalid() { +fn l555_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 2, 64, 65, 1, 13, 5, 11, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 540 +// Line 559 #[test] -fn l540_assert_invalid() { +fn l559_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 65, 1, 13, 129, 128, 128, 128, 1, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); @@ -1651,66 +1720,56 @@ fn test_module_1() { let result_object = create_module_1(); let vm_context = result_object.instance.generate_context(); // We group the calls together - l321_assert_return_invoke(&result_object, &vm_context); - l322_assert_return_invoke(&result_object, &vm_context); - l323_assert_return_invoke(&result_object, &vm_context); - l324_assert_return_invoke(&result_object, &vm_context); - l326_assert_return_invoke(&result_object, &vm_context); - l327_assert_return_invoke(&result_object, &vm_context); - l328_assert_return_invoke(&result_object, &vm_context); - l329_assert_return_invoke(&result_object, &vm_context); - l331_assert_return_invoke(&result_object, &vm_context); - l332_assert_return_invoke(&result_object, &vm_context); - l333_assert_return_invoke(&result_object, &vm_context); l334_assert_return_invoke(&result_object, &vm_context); l335_assert_return_invoke(&result_object, &vm_context); l336_assert_return_invoke(&result_object, &vm_context); - l338_assert_return_invoke(&result_object, &vm_context); + l337_assert_return_invoke(&result_object, &vm_context); l339_assert_return_invoke(&result_object, &vm_context); l340_assert_return_invoke(&result_object, &vm_context); l341_assert_return_invoke(&result_object, &vm_context); l342_assert_return_invoke(&result_object, &vm_context); - l343_assert_return_invoke(&result_object, &vm_context); + l344_assert_return_invoke(&result_object, &vm_context); l345_assert_return_invoke(&result_object, &vm_context); l346_assert_return_invoke(&result_object, &vm_context); l347_assert_return_invoke(&result_object, &vm_context); l348_assert_return_invoke(&result_object, &vm_context); l349_assert_return_invoke(&result_object, &vm_context); - l350_assert_return_invoke(&result_object, &vm_context); + l351_assert_return_invoke(&result_object, &vm_context); l352_assert_return_invoke(&result_object, &vm_context); + l353_assert_return_invoke(&result_object, &vm_context); l354_assert_return_invoke(&result_object, &vm_context); l355_assert_return_invoke(&result_object, &vm_context); l356_assert_return_invoke(&result_object, &vm_context); - l357_assert_return_invoke(&result_object, &vm_context); + l358_assert_return_invoke(&result_object, &vm_context); l359_assert_return_invoke(&result_object, &vm_context); l360_assert_return_invoke(&result_object, &vm_context); l361_assert_return_invoke(&result_object, &vm_context); + l362_assert_return_invoke(&result_object, &vm_context); l363_assert_return_invoke(&result_object, &vm_context); l365_assert_return_invoke(&result_object, &vm_context); - l366_assert_return_invoke(&result_object, &vm_context); l367_assert_return_invoke(&result_object, &vm_context); l368_assert_return_invoke(&result_object, &vm_context); l369_assert_return_invoke(&result_object, &vm_context); l370_assert_return_invoke(&result_object, &vm_context); - l371_assert_return_invoke(&result_object, &vm_context); l372_assert_return_invoke(&result_object, &vm_context); l373_assert_return_invoke(&result_object, &vm_context); l374_assert_return_invoke(&result_object, &vm_context); l376_assert_return_invoke(&result_object, &vm_context); - l377_assert_return_invoke(&result_object, &vm_context); l378_assert_return_invoke(&result_object, &vm_context); l379_assert_return_invoke(&result_object, &vm_context); l380_assert_return_invoke(&result_object, &vm_context); + l381_assert_return_invoke(&result_object, &vm_context); l382_assert_return_invoke(&result_object, &vm_context); l383_assert_return_invoke(&result_object, &vm_context); l384_assert_return_invoke(&result_object, &vm_context); + l385_assert_return_invoke(&result_object, &vm_context); l386_assert_return_invoke(&result_object, &vm_context); l387_assert_return_invoke(&result_object, &vm_context); - l388_assert_return_invoke(&result_object, &vm_context); l389_assert_return_invoke(&result_object, &vm_context); + l390_assert_return_invoke(&result_object, &vm_context); l391_assert_return_invoke(&result_object, &vm_context); l392_assert_return_invoke(&result_object, &vm_context); - l394_assert_return_invoke(&result_object, &vm_context); + l393_assert_return_invoke(&result_object, &vm_context); l395_assert_return_invoke(&result_object, &vm_context); l396_assert_return_invoke(&result_object, &vm_context); l397_assert_return_invoke(&result_object, &vm_context); @@ -1718,12 +1777,26 @@ fn test_module_1() { l400_assert_return_invoke(&result_object, &vm_context); l401_assert_return_invoke(&result_object, &vm_context); l402_assert_return_invoke(&result_object, &vm_context); - l403_assert_return_invoke(&result_object, &vm_context); l404_assert_return_invoke(&result_object, &vm_context); l405_assert_return_invoke(&result_object, &vm_context); - l406_assert_return_invoke(&result_object, &vm_context); l407_assert_return_invoke(&result_object, &vm_context); l408_assert_return_invoke(&result_object, &vm_context); - l409_assert_return_invoke(&result_object, &vm_context); l410_assert_return_invoke(&result_object, &vm_context); + l411_assert_return_invoke(&result_object, &vm_context); + l413_assert_return_invoke(&result_object, &vm_context); + l414_assert_return_invoke(&result_object, &vm_context); + l415_assert_return_invoke(&result_object, &vm_context); + l416_assert_return_invoke(&result_object, &vm_context); + l418_assert_return_invoke(&result_object, &vm_context); + l419_assert_return_invoke(&result_object, &vm_context); + l420_assert_return_invoke(&result_object, &vm_context); + l421_assert_return_invoke(&result_object, &vm_context); + l422_assert_return_invoke(&result_object, &vm_context); + l423_assert_return_invoke(&result_object, &vm_context); + l424_assert_return_invoke(&result_object, &vm_context); + l425_assert_return_invoke(&result_object, &vm_context); + l426_assert_return_invoke(&result_object, &vm_context); + l427_assert_return_invoke(&result_object, &vm_context); + l428_assert_return_invoke(&result_object, &vm_context); + l429_assert_return_invoke(&result_object, &vm_context); } diff --git a/src/spectests/br_table.rs b/src/spectests/br_table.rs index 0e37ed816..f4ce13af9 100644 --- a/src/spectests/br_table.rs +++ b/src/spectests/br_table.rs @@ -450,21 +450,38 @@ fn create_module_1() -> ResultObject { set_local 0 i32.const -1 end) - (func (;46;) (type 4) (result f32) + (func (;46;) (type 2) (result i32) + (local i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_table 0 (;@1;) + set_local 0 + i32.const -1 + end) + (func (;47;) (type 2) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 1 + br_table 0 (;@1;) + set_global 0 + i32.const -1 + end) + (func (;48;) (type 4) (result f32) block (result f32) ;; label = @1 f32.const 0x1.b33334p+0 (;=1.7;) i32.const 1 br_table 0 (;@1;) f32.load end) - (func (;47;) (type 3) (result i64) + (func (;49;) (type 3) (result i64) block (result i64) ;; label = @1 i64.const 30 i32.const 1 br_table 0 (;@1;) i64.load8_s end) - (func (;48;) (type 2) (result i32) + (func (;50;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 30 i32.const 1 @@ -473,7 +490,7 @@ fn create_module_1() -> ResultObject { f64.store i32.const -1 end) - (func (;49;) (type 2) (result i32) + (func (;51;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 2 i32.const 31 @@ -482,7 +499,7 @@ fn create_module_1() -> ResultObject { i64.store i32.const -1 end) - (func (;50;) (type 2) (result i32) + (func (;52;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 32 i32.const 0 @@ -491,7 +508,7 @@ fn create_module_1() -> ResultObject { i32.store8 i32.const -1 end) - (func (;51;) (type 2) (result i32) + (func (;53;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 2 i32.const 33 @@ -500,14 +517,14 @@ fn create_module_1() -> ResultObject { i64.store16 i32.const -1 end) - (func (;52;) (type 4) (result f32) + (func (;54;) (type 4) (result f32) block (result f32) ;; label = @1 f32.const 0x1.b33334p+1 (;=3.4;) i32.const 0 br_table 0 (;@1;) f32.neg end) - (func (;53;) (type 2) (result i32) + (func (;55;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 3 i32.const 0 @@ -515,7 +532,7 @@ fn create_module_1() -> ResultObject { i32.const 10 i32.add end) - (func (;54;) (type 3) (result i64) + (func (;56;) (type 3) (result i64) block (result i64) ;; label = @1 i64.const 10 i64.const 45 @@ -523,14 +540,14 @@ fn create_module_1() -> ResultObject { br_table 0 (;@1;) i64.sub end) - (func (;55;) (type 2) (result i32) + (func (;57;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 44 i32.const 0 br_table 0 (;@1;) i32.eqz end) - (func (;56;) (type 2) (result i32) + (func (;58;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 43 i32.const 0 @@ -538,7 +555,7 @@ fn create_module_1() -> ResultObject { f64.const 0x1.4p+3 (;=10;) f64.le end) - (func (;57;) (type 2) (result i32) + (func (;59;) (type 2) (result i32) block (result i32) ;; label = @1 f32.const 0x1.4p+3 (;=10;) i32.const 42 @@ -546,21 +563,21 @@ fn create_module_1() -> ResultObject { br_table 0 (;@1;) f32.ne end) - (func (;58;) (type 2) (result i32) + (func (;60;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 41 i32.const 0 br_table 0 (;@1;) i32.wrap/i64 end) - (func (;59;) (type 2) (result i32) + (func (;61;) (type 2) (result i32) block (result i32) ;; label = @1 i32.const 40 i32.const 0 br_table 0 (;@1;) memory.grow end) - (func (;60;) (type 6) (param i32) (result i32) + (func (;62;) (type 6) (param i32) (result i32) block (result i32) ;; label = @1 i32.const -1 drop @@ -580,7 +597,7 @@ fn create_module_1() -> ResultObject { end i32.add end) - (func (;61;) (type 6) (param i32) (result i32) + (func (;63;) (type 6) (param i32) (result i32) block (result i32) ;; label = @1 i32.const 1 block (result i32) ;; label = @2 @@ -599,7 +616,7 @@ fn create_module_1() -> ResultObject { end i32.add end) - (func (;62;) (type 6) (param i32) (result i32) + (func (;64;) (type 6) (param i32) (result i32) block (result i32) ;; label = @1 i32.const 1 block (result i32) ;; label = @2 @@ -621,7 +638,7 @@ fn create_module_1() -> ResultObject { end i32.add end) - (func (;63;) (type 6) (param i32) (result i32) + (func (;65;) (type 6) (param i32) (result i32) block (result i32) ;; label = @1 i32.const 1 block (result i32) ;; label = @2 @@ -637,7 +654,7 @@ fn create_module_1() -> ResultObject { end i32.add end) - (func (;64;) (type 6) (param i32) (result i32) + (func (;66;) (type 6) (param i32) (result i32) block (result i32) ;; label = @1 i32.const 1 block (result i32) ;; label = @2 @@ -658,7 +675,7 @@ fn create_module_1() -> ResultObject { end i32.add end) - (func (;65;) (type 6) (param i32) (result i32) + (func (;67;) (type 6) (param i32) (result i32) block (result i32) ;; label = @1 i32.const 1 block (result i32) ;; label = @2 @@ -673,7 +690,7 @@ fn create_module_1() -> ResultObject { end i32.add end) - (func (;66;) (type 6) (param i32) (result i32) + (func (;68;) (type 6) (param i32) (result i32) loop (result i32) ;; label = @1 block ;; label = @2 get_local 0 @@ -691,6 +708,7 @@ fn create_module_1() -> ResultObject { end) (table (;0;) 1 1 anyfunc) (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) (export \"type-i32\" (func 1)) (export \"type-i64\" (func 2)) (export \"type-f32\" (func 3)) @@ -735,36 +753,38 @@ fn create_module_1() -> ResultObject { (export \"as-call_indirect-last\" (func 43)) (export \"as-call_indirect-func\" (func 44)) (export \"as-set_local-value\" (func 45)) - (export \"as-load-address\" (func 46)) - (export \"as-loadN-address\" (func 47)) - (export \"as-store-address\" (func 48)) - (export \"as-store-value\" (func 49)) - (export \"as-storeN-address\" (func 50)) - (export \"as-storeN-value\" (func 51)) - (export \"as-unary-operand\" (func 52)) - (export \"as-binary-left\" (func 53)) - (export \"as-binary-right\" (func 54)) - (export \"as-test-operand\" (func 55)) - (export \"as-compare-left\" (func 56)) - (export \"as-compare-right\" (func 57)) - (export \"as-convert-operand\" (func 58)) - (export \"as-memory.grow-size\" (func 59)) - (export \"nested-block-value\" (func 60)) - (export \"nested-br-value\" (func 61)) - (export \"nested-br_if-value\" (func 62)) - (export \"nested-br_if-value-cond\" (func 63)) - (export \"nested-br_table-value\" (func 64)) - (export \"nested-br_table-value-index\" (func 65)) - (export \"nested-br_table-loop-block\" (func 66)) + (export \"as-tee_local-value\" (func 46)) + (export \"as-set_global-value\" (func 47)) + (export \"as-load-address\" (func 48)) + (export \"as-loadN-address\" (func 49)) + (export \"as-store-address\" (func 50)) + (export \"as-store-value\" (func 51)) + (export \"as-storeN-address\" (func 52)) + (export \"as-storeN-value\" (func 53)) + (export \"as-unary-operand\" (func 54)) + (export \"as-binary-left\" (func 55)) + (export \"as-binary-right\" (func 56)) + (export \"as-test-operand\" (func 57)) + (export \"as-compare-left\" (func 58)) + (export \"as-compare-right\" (func 59)) + (export \"as-convert-operand\" (func 60)) + (export \"as-memory.grow-size\" (func 61)) + (export \"nested-block-value\" (func 62)) + (export \"nested-br-value\" (func 63)) + (export \"nested-br_if-value\" (func 64)) + (export \"nested-br_if-value-cond\" (func 65)) + (export \"nested-br_table-value\" (func 66)) + (export \"nested-br_table-value-index\" (func 67)) + (export \"nested-br_table-loop-block\" (func 68)) (elem (i32.const 0) 37)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") } -// Line 1233 -fn l1233_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1233_assert_return_invoke"); +// Line 1247 +fn l1247_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1247_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -774,9 +794,9 @@ fn l1233_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, ()); } -// Line 1234 -fn l1234_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1234_assert_return_invoke"); +// Line 1248 +fn l1248_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1248_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -786,9 +806,9 @@ fn l1234_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, ()); } -// Line 1235 -fn l1235_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1235_assert_return_invoke"); +// Line 1249 +fn l1249_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1249_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -798,9 +818,9 @@ fn l1235_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, ()); } -// Line 1236 -fn l1236_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1236_assert_return_invoke"); +// Line 1250 +fn l1250_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1250_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -810,9 +830,9 @@ fn l1236_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, ()); } -// Line 1238 -fn l1238_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1238_assert_return_invoke"); +// Line 1252 +fn l1252_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1252_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -822,9 +842,9 @@ fn l1238_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1 as i32); } -// Line 1239 -fn l1239_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1239_assert_return_invoke"); +// Line 1253 +fn l1253_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1253_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -834,9 +854,9 @@ fn l1239_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 2 as i64); } -// Line 1240 -fn l1240_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1240_assert_return_invoke"); +// Line 1254 +fn l1254_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1254_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -846,9 +866,9 @@ fn l1240_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 3.0 as f32); } -// Line 1241 -fn l1241_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1241_assert_return_invoke"); +// Line 1255 +fn l1255_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1255_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f64-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -858,154 +878,10 @@ fn l1241_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 4.0 as f64); } -// Line 1243 -fn l1243_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1243_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(0 as i32, &vm_context); - assert_eq!(result, 22 as i32); -} - -// Line 1244 -fn l1244_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1244_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(1 as i32, &vm_context); - assert_eq!(result, 22 as i32); -} - -// Line 1245 -fn l1245_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1245_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(11 as i32, &vm_context); - assert_eq!(result, 22 as i32); -} - -// Line 1246 -fn l1246_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1246_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-1 as i32, &vm_context); - assert_eq!(result, 22 as i32); -} - -// Line 1247 -fn l1247_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1247_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-100 as i32, &vm_context); - assert_eq!(result, 22 as i32); -} - -// Line 1248 -fn l1248_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1248_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-1 as i32, &vm_context); - assert_eq!(result, 22 as i32); -} - -// Line 1250 -fn l1250_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1250_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(0 as i32, &vm_context); - assert_eq!(result, 33 as i32); -} - -// Line 1251 -fn l1251_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1251_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(1 as i32, &vm_context); - assert_eq!(result, 33 as i32); -} - -// Line 1252 -fn l1252_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1252_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(11 as i32, &vm_context); - assert_eq!(result, 33 as i32); -} - -// Line 1253 -fn l1253_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1253_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-1 as i32, &vm_context); - assert_eq!(result, 33 as i32); -} - -// Line 1254 -fn l1254_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1254_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-100 as i32, &vm_context); - assert_eq!(result, 33 as i32); -} - -// Line 1255 -fn l1255_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1255_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("empty-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-1 as i32, &vm_context); - assert_eq!(result, 33 as i32); -} - // Line 1257 fn l1257_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1257_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton") { + let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1017,79 +893,79 @@ fn l1257_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1258 fn l1258_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1258_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton") { + let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(1 as i32, &vm_context); - assert_eq!(result, 20 as i32); + assert_eq!(result, 22 as i32); } // Line 1259 fn l1259_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1259_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton") { + let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(11 as i32, &vm_context); - assert_eq!(result, 20 as i32); + assert_eq!(result, 22 as i32); } // Line 1260 fn l1260_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1260_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton") { + let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(-1 as i32, &vm_context); - assert_eq!(result, 20 as i32); + assert_eq!(result, 22 as i32); } // Line 1261 fn l1261_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1261_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton") { + let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(-100 as i32, &vm_context); - assert_eq!(result, 20 as i32); + assert_eq!(result, 22 as i32); } // Line 1262 fn l1262_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1262_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton") { + let func_index = match result_object.module.info.exports.get("empty") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(-1 as i32, &vm_context); - assert_eq!(result, 20 as i32); + assert_eq!(result, 22 as i32); } // Line 1264 fn l1264_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1264_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton-value") { + let func_index = match result_object.module.info.exports.get("empty-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); let result = invoke_fn(0 as i32, &vm_context); - assert_eq!(result, 32 as i32); + assert_eq!(result, 33 as i32); } // Line 1265 fn l1265_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1265_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton-value") { + let func_index = match result_object.module.info.exports.get("empty-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1101,7 +977,7 @@ fn l1265_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1266 fn l1266_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1266_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton-value") { + let func_index = match result_object.module.info.exports.get("empty-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1113,7 +989,7 @@ fn l1266_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1267 fn l1267_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1267_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton-value") { + let func_index = match result_object.module.info.exports.get("empty-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1125,7 +1001,7 @@ fn l1267_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1268 fn l1268_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1268_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton-value") { + let func_index = match result_object.module.info.exports.get("empty-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1137,7 +1013,7 @@ fn l1268_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1269 fn l1269_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1269_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("singleton-value") { + let func_index = match result_object.module.info.exports.get("empty-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1149,6 +1025,150 @@ fn l1269_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1271 fn l1271_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1271_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, 22 as i32); +} + +// Line 1272 +fn l1272_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1272_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 20 as i32); +} + +// Line 1273 +fn l1273_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1273_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(11 as i32, &vm_context); + assert_eq!(result, 20 as i32); +} + +// Line 1274 +fn l1274_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1274_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1 as i32, &vm_context); + assert_eq!(result, 20 as i32); +} + +// Line 1275 +fn l1275_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1275_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-100 as i32, &vm_context); + assert_eq!(result, 20 as i32); +} + +// Line 1276 +fn l1276_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1276_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1 as i32, &vm_context); + assert_eq!(result, 20 as i32); +} + +// Line 1278 +fn l1278_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1278_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, 32 as i32); +} + +// Line 1279 +fn l1279_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1279_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 33 as i32); +} + +// Line 1280 +fn l1280_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1280_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(11 as i32, &vm_context); + assert_eq!(result, 33 as i32); +} + +// Line 1281 +fn l1281_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1281_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1 as i32, &vm_context); + assert_eq!(result, 33 as i32); +} + +// Line 1282 +fn l1282_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1282_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-100 as i32, &vm_context); + assert_eq!(result, 33 as i32); +} + +// Line 1283 +fn l1283_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1283_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("singleton-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1 as i32, &vm_context); + assert_eq!(result, 33 as i32); +} + +// Line 1285 +fn l1285_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1285_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1158,9 +1178,9 @@ fn l1271_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 103 as i32); } -// Line 1272 -fn l1272_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1272_assert_return_invoke"); +// Line 1286 +fn l1286_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1286_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1170,9 +1190,9 @@ fn l1272_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 102 as i32); } -// Line 1273 -fn l1273_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1273_assert_return_invoke"); +// Line 1287 +fn l1287_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1287_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1182,9 +1202,9 @@ fn l1273_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 101 as i32); } -// Line 1274 -fn l1274_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1274_assert_return_invoke"); +// Line 1288 +fn l1288_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1288_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1194,9 +1214,9 @@ fn l1274_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 100 as i32); } -// Line 1275 -fn l1275_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1275_assert_return_invoke"); +// Line 1289 +fn l1289_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1289_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1206,9 +1226,9 @@ fn l1275_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 104 as i32); } -// Line 1276 -fn l1276_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1276_assert_return_invoke"); +// Line 1290 +fn l1290_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1290_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1218,9 +1238,9 @@ fn l1276_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 104 as i32); } -// Line 1277 -fn l1277_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1277_assert_return_invoke"); +// Line 1291 +fn l1291_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1291_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1230,9 +1250,9 @@ fn l1277_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 104 as i32); } -// Line 1278 -fn l1278_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1278_assert_return_invoke"); +// Line 1292 +fn l1292_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1292_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1242,9 +1262,9 @@ fn l1278_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 104 as i32); } -// Line 1279 -fn l1279_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1279_assert_return_invoke"); +// Line 1293 +fn l1293_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1293_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1254,9 +1274,9 @@ fn l1279_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 104 as i32); } -// Line 1280 -fn l1280_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1280_assert_return_invoke"); +// Line 1294 +fn l1294_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1294_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1266,9 +1286,9 @@ fn l1280_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 104 as i32); } -// Line 1282 -fn l1282_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1282_assert_return_invoke"); +// Line 1296 +fn l1296_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1296_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1278,9 +1298,9 @@ fn l1282_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 213 as i32); } -// Line 1283 -fn l1283_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1283_assert_return_invoke"); +// Line 1297 +fn l1297_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1297_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1290,9 +1310,9 @@ fn l1283_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 212 as i32); } -// Line 1284 -fn l1284_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1284_assert_return_invoke"); +// Line 1298 +fn l1298_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1298_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1302,9 +1322,9 @@ fn l1284_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 211 as i32); } -// Line 1285 -fn l1285_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1285_assert_return_invoke"); +// Line 1299 +fn l1299_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1299_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1314,9 +1334,9 @@ fn l1285_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 210 as i32); } -// Line 1286 -fn l1286_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1286_assert_return_invoke"); +// Line 1300 +fn l1300_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1300_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1326,9 +1346,9 @@ fn l1286_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 214 as i32); } -// Line 1287 -fn l1287_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1287_assert_return_invoke"); +// Line 1301 +fn l1301_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1301_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1338,9 +1358,9 @@ fn l1287_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 214 as i32); } -// Line 1288 -fn l1288_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1288_assert_return_invoke"); +// Line 1302 +fn l1302_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1302_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1350,9 +1370,9 @@ fn l1288_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 214 as i32); } -// Line 1289 -fn l1289_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1289_assert_return_invoke"); +// Line 1303 +fn l1303_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1303_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1362,9 +1382,9 @@ fn l1289_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 214 as i32); } -// Line 1290 -fn l1290_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1290_assert_return_invoke"); +// Line 1304 +fn l1304_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1304_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1374,9 +1394,9 @@ fn l1290_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 214 as i32); } -// Line 1291 -fn l1291_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1291_assert_return_invoke"); +// Line 1305 +fn l1305_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1305_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("multiple-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1386,9 +1406,9 @@ fn l1291_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 214 as i32); } -// Line 1293 -fn l1293_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1293_assert_return_invoke"); +// Line 1307 +fn l1307_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1307_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1398,9 +1418,9 @@ fn l1293_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 0 as i32); } -// Line 1294 -fn l1294_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1294_assert_return_invoke"); +// Line 1308 +fn l1308_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1308_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1410,9 +1430,9 @@ fn l1294_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1 as i32); } -// Line 1295 -fn l1295_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1295_assert_return_invoke"); +// Line 1309 +fn l1309_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1309_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1422,9 +1442,9 @@ fn l1295_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 0 as i32); } -// Line 1296 -fn l1296_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1296_assert_return_invoke"); +// Line 1310 +fn l1310_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1310_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1434,9 +1454,9 @@ fn l1296_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1 as i32); } -// Line 1297 -fn l1297_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1297_assert_return_invoke"); +// Line 1311 +fn l1311_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1311_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1446,9 +1466,9 @@ fn l1297_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 0 as i32); } -// Line 1298 -fn l1298_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1298_assert_return_invoke"); +// Line 1312 +fn l1312_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1312_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1458,9 +1478,9 @@ fn l1298_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1 as i32); } -// Line 1299 -fn l1299_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1299_assert_return_invoke"); +// Line 1313 +fn l1313_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1313_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1470,9 +1490,9 @@ fn l1299_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1 as i32); } -// Line 1300 -fn l1300_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1300_assert_return_invoke"); +// Line 1314 +fn l1314_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1314_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("large") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1482,9 +1502,9 @@ fn l1300_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1 as i32); } -// Line 1302 -fn l1302_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1302_assert_return_invoke"); +// Line 1316 +fn l1316_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1316_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-block-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1494,130 +1514,10 @@ fn l1302_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, ()); } -// Line 1303 -fn l1303_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1303_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-block-mid") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 1304 -fn l1304_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1304_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-block-last") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 1305 -fn l1305_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1305_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-block-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 2 as i32); -} - -// Line 1307 -fn l1307_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1307_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-loop-first") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 3 as i32); -} - -// Line 1308 -fn l1308_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1308_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-loop-mid") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 4 as i32); -} - -// Line 1309 -fn l1309_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1309_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-loop-last") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 5 as i32); -} - -// Line 1311 -fn l1311_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1311_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1313 -fn l1313_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1313_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_if-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, ()); -} - -// Line 1314 -fn l1314_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1314_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 8 as i32); -} - -// Line 1315 -fn l1315_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1315_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(&vm_context); - assert_eq!(result, 9 as i32); -} - // Line 1317 fn l1317_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1317_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("as-br_table-index") { + let func_index = match result_object.module.info.exports.get("as-block-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; @@ -1629,6 +1529,126 @@ fn l1317_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) // Line 1318 fn l1318_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1318_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-block-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 1319 +fn l1319_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1319_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-block-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + +// Line 1321 +fn l1321_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1321_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-loop-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 3 as i32); +} + +// Line 1322 +fn l1322_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1322_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-loop-mid") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 4 as i32); +} + +// Line 1323 +fn l1323_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1323_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-loop-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 5 as i32); +} + +// Line 1325 +fn l1325_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1325_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1327 +fn l1327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1327_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_if-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 1328 +fn l1328_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1328_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_if-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1329 +fn l1329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1329_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1331 +fn l1331_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1331_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_table-index") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 1332 +fn l1332_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1332_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1638,9 +1658,9 @@ fn l1318_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 10 as i32); } -// Line 1319 -fn l1319_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1319_assert_return_invoke"); +// Line 1333 +fn l1333_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1333_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1650,9 +1670,9 @@ fn l1319_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 11 as i32); } -// Line 1321 -fn l1321_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1321_assert_return_invoke"); +// Line 1335 +fn l1335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1335_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-return-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1662,9 +1682,9 @@ fn l1321_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 7 as i64); } -// Line 1323 -fn l1323_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1323_assert_return_invoke"); +// Line 1337 +fn l1337_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1337_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1674,9 +1694,9 @@ fn l1323_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 2 as i32); } -// Line 1324 -fn l1324_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1324_assert_return_invoke"); +// Line 1338 +fn l1338_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1338_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1686,9 +1706,9 @@ fn l1324_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 3 as i32); } -// Line 1325 -fn l1325_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1325_assert_return_invoke"); +// Line 1339 +fn l1339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1339_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-then") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1698,9 +1718,9 @@ fn l1325_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 6 as i32); } -// Line 1326 -fn l1326_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1326_assert_return_invoke"); +// Line 1340 +fn l1340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1340_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1710,9 +1730,9 @@ fn l1326_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 4 as i32); } -// Line 1327 -fn l1327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1327_assert_return_invoke"); +// Line 1341 +fn l1341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1341_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-else") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1722,9 +1742,9 @@ fn l1327_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 6 as i32); } -// Line 1329 -fn l1329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1329_assert_return_invoke"); +// Line 1343 +fn l1343_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1343_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1734,9 +1754,9 @@ fn l1329_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 5 as i32); } -// Line 1330 -fn l1330_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1330_assert_return_invoke"); +// Line 1344 +fn l1344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1344_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1746,9 +1766,9 @@ fn l1330_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 5 as i32); } -// Line 1331 -fn l1331_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1331_assert_return_invoke"); +// Line 1345 +fn l1345_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1345_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-second") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1758,9 +1778,9 @@ fn l1331_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 6 as i32); } -// Line 1332 -fn l1332_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1332_assert_return_invoke"); +// Line 1346 +fn l1346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1346_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-second") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1770,9 +1790,9 @@ fn l1332_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 6 as i32); } -// Line 1333 -fn l1333_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1333_assert_return_invoke"); +// Line 1347 +fn l1347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1347_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-cond") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1782,9 +1802,9 @@ fn l1333_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 7 as i32); } -// Line 1335 -fn l1335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1335_assert_return_invoke"); +// Line 1349 +fn l1349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1349_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1794,9 +1814,9 @@ fn l1335_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 12 as i32); } -// Line 1336 -fn l1336_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1336_assert_return_invoke"); +// Line 1350 +fn l1350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1350_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1806,9 +1826,9 @@ fn l1336_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 13 as i32); } -// Line 1337 -fn l1337_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1337_assert_return_invoke"); +// Line 1351 +fn l1351_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1351_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1818,9 +1838,9 @@ fn l1337_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 14 as i32); } -// Line 1339 -fn l1339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1339_assert_return_invoke"); +// Line 1353 +fn l1353_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1353_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1830,9 +1850,9 @@ fn l1339_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 20 as i32); } -// Line 1340 -fn l1340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1340_assert_return_invoke"); +// Line 1354 +fn l1354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1354_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1842,9 +1862,9 @@ fn l1340_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 21 as i32); } -// Line 1341 -fn l1341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1341_assert_return_invoke"); +// Line 1355 +fn l1355_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1355_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1854,9 +1874,9 @@ fn l1341_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 22 as i32); } -// Line 1342 -fn l1342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1342_assert_return_invoke"); +// Line 1356 +fn l1356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1356_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-call_indirect-func") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1866,9 +1886,9 @@ fn l1342_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 23 as i32); } -// Line 1344 -fn l1344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1344_assert_return_invoke"); +// Line 1358 +fn l1358_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1358_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-set_local-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1878,9 +1898,33 @@ fn l1344_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 17 as i32); } -// Line 1346 -fn l1346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1346_assert_return_invoke"); +// Line 1359 +fn l1359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1359_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 1360 +fn l1360_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1360_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 1362 +fn l1362_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1362_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-load-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1890,9 +1934,9 @@ fn l1346_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 1.7 as f32); } -// Line 1347 -fn l1347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1347_assert_return_invoke"); +// Line 1363 +fn l1363_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1363_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-loadN-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1902,9 +1946,9 @@ fn l1347_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 30 as i64); } -// Line 1349 -fn l1349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1349_assert_return_invoke"); +// Line 1365 +fn l1365_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1365_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-store-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1914,9 +1958,9 @@ fn l1349_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 30 as i32); } -// Line 1350 -fn l1350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1350_assert_return_invoke"); +// Line 1366 +fn l1366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1366_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-store-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1926,9 +1970,9 @@ fn l1350_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 31 as i32); } -// Line 1351 -fn l1351_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1351_assert_return_invoke"); +// Line 1367 +fn l1367_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1367_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-storeN-address") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1938,9 +1982,9 @@ fn l1351_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 32 as i32); } -// Line 1352 -fn l1352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1352_assert_return_invoke"); +// Line 1368 +fn l1368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1368_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-storeN-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1950,9 +1994,9 @@ fn l1352_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 33 as i32); } -// Line 1354 -fn l1354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1354_assert_return_invoke"); +// Line 1370 +fn l1370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1370_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-unary-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1962,9 +2006,9 @@ fn l1354_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 3.4 as f32); } -// Line 1356 -fn l1356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1356_assert_return_invoke"); +// Line 1372 +fn l1372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1372_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-left") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1974,9 +2018,9 @@ fn l1356_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 3 as i32); } -// Line 1357 -fn l1357_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1357_assert_return_invoke"); +// Line 1373 +fn l1373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1373_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-binary-right") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1986,9 +2030,9 @@ fn l1357_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 45 as i64); } -// Line 1359 -fn l1359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1359_assert_return_invoke"); +// Line 1375 +fn l1375_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1375_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-test-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1998,9 +2042,9 @@ fn l1359_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 44 as i32); } -// Line 1361 -fn l1361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1361_assert_return_invoke"); +// Line 1377 +fn l1377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1377_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-compare-left") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2010,9 +2054,9 @@ fn l1361_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 43 as i32); } -// Line 1362 -fn l1362_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1362_assert_return_invoke"); +// Line 1378 +fn l1378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1378_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-compare-right") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2022,9 +2066,9 @@ fn l1362_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 42 as i32); } -// Line 1364 -fn l1364_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1364_assert_return_invoke"); +// Line 1380 +fn l1380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1380_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-convert-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2034,9 +2078,9 @@ fn l1364_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 41 as i32); } -// Line 1366 -fn l1366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1366_assert_return_invoke"); +// Line 1382 +fn l1382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1382_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-memory.grow-size") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2046,9 +2090,9 @@ fn l1366_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 40 as i32); } -// Line 1368 -fn l1368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1368_assert_return_invoke"); +// Line 1384 +fn l1384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1384_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2058,9 +2102,9 @@ fn l1368_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 19 as i32); } -// Line 1369 -fn l1369_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1369_assert_return_invoke"); +// Line 1385 +fn l1385_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1385_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2070,9 +2114,9 @@ fn l1369_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 17 as i32); } -// Line 1370 -fn l1370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1370_assert_return_invoke"); +// Line 1386 +fn l1386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1386_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2082,9 +2126,9 @@ fn l1370_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 16 as i32); } -// Line 1371 -fn l1371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1371_assert_return_invoke"); +// Line 1387 +fn l1387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1387_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2094,9 +2138,9 @@ fn l1371_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 16 as i32); } -// Line 1372 -fn l1372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1372_assert_return_invoke"); +// Line 1388 +fn l1388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1388_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2106,9 +2150,9 @@ fn l1372_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 16 as i32); } -// Line 1373 -fn l1373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1373_assert_return_invoke"); +// Line 1389 +fn l1389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1389_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-block-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2118,9 +2162,9 @@ fn l1373_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 16 as i32); } -// Line 1375 -fn l1375_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1375_assert_return_invoke"); +// Line 1391 +fn l1391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1391_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2130,9 +2174,9 @@ fn l1375_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 8 as i32); } -// Line 1376 -fn l1376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1376_assert_return_invoke"); +// Line 1392 +fn l1392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1392_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2142,9 +2186,9 @@ fn l1376_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 9 as i32); } -// Line 1377 -fn l1377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1377_assert_return_invoke"); +// Line 1393 +fn l1393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1393_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2154,9 +2198,9 @@ fn l1377_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 17 as i32); } -// Line 1378 -fn l1378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1378_assert_return_invoke"); +// Line 1394 +fn l1394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1394_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2166,9 +2210,9 @@ fn l1378_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 17 as i32); } -// Line 1379 -fn l1379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1379_assert_return_invoke"); +// Line 1395 +fn l1395_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1395_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2178,9 +2222,9 @@ fn l1379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 17 as i32); } -// Line 1380 -fn l1380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1380_assert_return_invoke"); +// Line 1396 +fn l1396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1396_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2190,213 +2234,213 @@ fn l1380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 17 as i32); } -// Line 1382 -fn l1382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1382_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(0 as i32, &vm_context); - assert_eq!(result, 17 as i32); -} - -// Line 1383 -fn l1383_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1383_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(1 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1384 -fn l1384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1384_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(2 as i32, &vm_context); - assert_eq!(result, 8 as i32); -} - -// Line 1385 -fn l1385_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1385_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(9 as i32, &vm_context); - assert_eq!(result, 8 as i32); -} - -// Line 1386 -fn l1386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1386_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-9 as i32, &vm_context); - assert_eq!(result, 8 as i32); -} - -// Line 1387 -fn l1387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1387_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(999999 as i32, &vm_context); - assert_eq!(result, 8 as i32); -} - -// Line 1389 -fn l1389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1389_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(0 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1390 -fn l1390_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1390_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(1 as i32, &vm_context); - assert_eq!(result, 8 as i32); -} - -// Line 1391 -fn l1391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1391_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(2 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1392 -fn l1392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1392_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(3 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1393 -fn l1393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1393_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-1000000 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1394 -fn l1394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1394_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(9423975 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - -// Line 1396 -fn l1396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1396_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_table-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(0 as i32, &vm_context); - assert_eq!(result, 17 as i32); -} - -// Line 1397 -fn l1397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1397_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_table-value") { - Some(&Export::Function(index)) => index, - _ => panic!("Function not found"), - }; - let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(1 as i32, &vm_context); - assert_eq!(result, 9 as i32); -} - // Line 1398 fn l1398_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1398_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + let func_index = match result_object.module.info.exports.get("nested-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(2 as i32, &vm_context); - assert_eq!(result, 8 as i32); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, 17 as i32); } // Line 1399 fn l1399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1399_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + let func_index = match result_object.module.info.exports.get("nested-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(9 as i32, &vm_context); - assert_eq!(result, 8 as i32); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 9 as i32); } // Line 1400 fn l1400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1400_assert_return_invoke"); - let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + let func_index = match result_object.module.info.exports.get("nested-br_if-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), }; let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); - let result = invoke_fn(-9 as i32, &vm_context); + let result = invoke_fn(2 as i32, &vm_context); assert_eq!(result, 8 as i32); } // Line 1401 fn l1401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { println!("Executing function {}", "l1401_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1402 +fn l1402_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1402_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-9 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1403 +fn l1403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1403_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(999999 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1405 +fn l1405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1405_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1406 +fn l1406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1406_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1407 +fn l1407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1407_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2 as i32, &vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1408 +fn l1408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1408_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(3 as i32, &vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1409 +fn l1409_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1409_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-1000000 as i32, &vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1410 +fn l1410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1410_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_if-value-cond") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9423975 as i32, &vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1412 +fn l1412_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1412_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(0 as i32, &vm_context); + assert_eq!(result, 17 as i32); +} + +// Line 1413 +fn l1413_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1413_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(1 as i32, &vm_context); + assert_eq!(result, 9 as i32); +} + +// Line 1414 +fn l1414_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1414_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(2 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1415 +fn l1415_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1415_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(9 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1416 +fn l1416_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1416_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("nested-br_table-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(i32, &VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(-9 as i32, &vm_context); + assert_eq!(result, 8 as i32); +} + +// Line 1417 +fn l1417_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1417_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2406,9 +2450,9 @@ fn l1401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 8 as i32); } -// Line 1403 -fn l1403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1403_assert_return_invoke"); +// Line 1419 +fn l1419_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1419_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2418,9 +2462,9 @@ fn l1403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 9 as i32); } -// Line 1404 -fn l1404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1404_assert_return_invoke"); +// Line 1420 +fn l1420_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1420_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2430,9 +2474,9 @@ fn l1404_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 8 as i32); } -// Line 1405 -fn l1405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1405_assert_return_invoke"); +// Line 1421 +fn l1421_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1421_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2442,9 +2486,9 @@ fn l1405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 9 as i32); } -// Line 1406 -fn l1406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1406_assert_return_invoke"); +// Line 1422 +fn l1422_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1422_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2454,9 +2498,9 @@ fn l1406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 9 as i32); } -// Line 1407 -fn l1407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1407_assert_return_invoke"); +// Line 1423 +fn l1423_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1423_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2466,9 +2510,9 @@ fn l1407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 9 as i32); } -// Line 1408 -fn l1408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1408_assert_return_invoke"); +// Line 1424 +fn l1424_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1424_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-value-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2478,9 +2522,9 @@ fn l1408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 9 as i32); } -// Line 1410 -fn l1410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l1410_assert_return_invoke"); +// Line 1426 +fn l1426_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l1426_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("nested-br_table-loop-block") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -2490,121 +2534,121 @@ fn l1410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) assert_eq!(result, 3 as i32); } -// Line 1413 +// Line 1429 #[test] -fn l1413_assert_invalid() { +fn l1429_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 14, 1, 12, 0, 2, 64, 65, 1, 14, 0, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1420 +// Line 1436 #[test] -fn l1420_assert_invalid() { +fn l1436_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 15, 1, 13, 0, 2, 127, 1, 65, 1, 14, 0, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1426 +// Line 1442 #[test] -fn l1426_assert_invalid() { +fn l1442_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 127, 66, 1, 65, 1, 14, 2, 0, 0, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1434 +// Line 1450 #[test] -fn l1434_assert_invalid() { +fn l1450_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 22, 1, 20, 0, 2, 64, 2, 125, 67, 0, 0, 0, 0, 65, 0, 14, 1, 0, 1, 11, 26, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1446 +// Line 1462 #[test] -fn l1446_assert_invalid() { +fn l1462_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 1, 14, 2, 0, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1452 +// Line 1468 #[test] -fn l1452_assert_invalid() { +fn l1468_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 12, 1, 10, 0, 2, 64, 66, 0, 14, 0, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1458 +// Line 1474 #[test] -fn l1458_assert_invalid() { +fn l1474_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 127, 65, 0, 1, 14, 1, 0, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1464 +// Line 1480 #[test] -fn l1464_assert_invalid() { +fn l1480_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 65, 0, 2, 64, 65, 0, 14, 0, 1, 11, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1470 +// Line 1486 #[test] -fn l1470_assert_invalid() { +fn l1486_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 5, 1, 96, 0, 1, 127, 3, 2, 1, 0, 10, 17, 1, 15, 0, 2, 127, 65, 0, 66, 0, 14, 1, 0, 0, 65, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1479 +// Line 1495 #[test] -fn l1479_assert_invalid() { +fn l1495_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 14, 1, 2, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1485 +// Line 1501 #[test] -fn l1485_assert_invalid() { +fn l1501_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, 65, 1, 14, 1, 0, 5, 11, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1491 +// Line 1507 #[test] -fn l1491_assert_invalid() { +fn l1507_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, 14, 2, 0, 129, 128, 128, 128, 1, 0, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1498 +// Line 1514 #[test] -fn l1498_assert_invalid() { +fn l1514_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 13, 1, 11, 0, 2, 64, 65, 1, 14, 1, 1, 2, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1504 +// Line 1520 #[test] -fn l1504_assert_invalid() { +fn l1520_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 16, 1, 14, 0, 2, 64, 2, 64, 65, 1, 14, 1, 0, 5, 11, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 1510 +// Line 1526 #[test] -fn l1510_assert_invalid() { +fn l1526_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 18, 1, 16, 0, 2, 64, 65, 1, 14, 2, 0, 0, 129, 128, 128, 128, 1, 11, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); @@ -2615,22 +2659,10 @@ fn test_module_1() { let result_object = create_module_1(); let vm_context = result_object.instance.generate_context(); // We group the calls together - l1233_assert_return_invoke(&result_object, &vm_context); - l1234_assert_return_invoke(&result_object, &vm_context); - l1235_assert_return_invoke(&result_object, &vm_context); - l1236_assert_return_invoke(&result_object, &vm_context); - l1238_assert_return_invoke(&result_object, &vm_context); - l1239_assert_return_invoke(&result_object, &vm_context); - l1240_assert_return_invoke(&result_object, &vm_context); - l1241_assert_return_invoke(&result_object, &vm_context); - l1243_assert_return_invoke(&result_object, &vm_context); - l1244_assert_return_invoke(&result_object, &vm_context); - l1245_assert_return_invoke(&result_object, &vm_context); - l1246_assert_return_invoke(&result_object, &vm_context); l1247_assert_return_invoke(&result_object, &vm_context); l1248_assert_return_invoke(&result_object, &vm_context); + l1249_assert_return_invoke(&result_object, &vm_context); l1250_assert_return_invoke(&result_object, &vm_context); - l1251_assert_return_invoke(&result_object, &vm_context); l1252_assert_return_invoke(&result_object, &vm_context); l1253_assert_return_invoke(&result_object, &vm_context); l1254_assert_return_invoke(&result_object, &vm_context); @@ -2653,13 +2685,12 @@ fn test_module_1() { l1274_assert_return_invoke(&result_object, &vm_context); l1275_assert_return_invoke(&result_object, &vm_context); l1276_assert_return_invoke(&result_object, &vm_context); - l1277_assert_return_invoke(&result_object, &vm_context); l1278_assert_return_invoke(&result_object, &vm_context); l1279_assert_return_invoke(&result_object, &vm_context); l1280_assert_return_invoke(&result_object, &vm_context); + l1281_assert_return_invoke(&result_object, &vm_context); l1282_assert_return_invoke(&result_object, &vm_context); l1283_assert_return_invoke(&result_object, &vm_context); - l1284_assert_return_invoke(&result_object, &vm_context); l1285_assert_return_invoke(&result_object, &vm_context); l1286_assert_return_invoke(&result_object, &vm_context); l1287_assert_return_invoke(&result_object, &vm_context); @@ -2667,14 +2698,15 @@ fn test_module_1() { l1289_assert_return_invoke(&result_object, &vm_context); l1290_assert_return_invoke(&result_object, &vm_context); l1291_assert_return_invoke(&result_object, &vm_context); + l1292_assert_return_invoke(&result_object, &vm_context); l1293_assert_return_invoke(&result_object, &vm_context); l1294_assert_return_invoke(&result_object, &vm_context); - l1295_assert_return_invoke(&result_object, &vm_context); l1296_assert_return_invoke(&result_object, &vm_context); l1297_assert_return_invoke(&result_object, &vm_context); l1298_assert_return_invoke(&result_object, &vm_context); l1299_assert_return_invoke(&result_object, &vm_context); l1300_assert_return_invoke(&result_object, &vm_context); + l1301_assert_return_invoke(&result_object, &vm_context); l1302_assert_return_invoke(&result_object, &vm_context); l1303_assert_return_invoke(&result_object, &vm_context); l1304_assert_return_invoke(&result_object, &vm_context); @@ -2682,81 +2714,95 @@ fn test_module_1() { l1307_assert_return_invoke(&result_object, &vm_context); l1308_assert_return_invoke(&result_object, &vm_context); l1309_assert_return_invoke(&result_object, &vm_context); + l1310_assert_return_invoke(&result_object, &vm_context); l1311_assert_return_invoke(&result_object, &vm_context); + l1312_assert_return_invoke(&result_object, &vm_context); l1313_assert_return_invoke(&result_object, &vm_context); l1314_assert_return_invoke(&result_object, &vm_context); - l1315_assert_return_invoke(&result_object, &vm_context); + l1316_assert_return_invoke(&result_object, &vm_context); l1317_assert_return_invoke(&result_object, &vm_context); l1318_assert_return_invoke(&result_object, &vm_context); l1319_assert_return_invoke(&result_object, &vm_context); l1321_assert_return_invoke(&result_object, &vm_context); + l1322_assert_return_invoke(&result_object, &vm_context); l1323_assert_return_invoke(&result_object, &vm_context); - l1324_assert_return_invoke(&result_object, &vm_context); l1325_assert_return_invoke(&result_object, &vm_context); - l1326_assert_return_invoke(&result_object, &vm_context); l1327_assert_return_invoke(&result_object, &vm_context); + l1328_assert_return_invoke(&result_object, &vm_context); l1329_assert_return_invoke(&result_object, &vm_context); - l1330_assert_return_invoke(&result_object, &vm_context); l1331_assert_return_invoke(&result_object, &vm_context); l1332_assert_return_invoke(&result_object, &vm_context); l1333_assert_return_invoke(&result_object, &vm_context); l1335_assert_return_invoke(&result_object, &vm_context); - l1336_assert_return_invoke(&result_object, &vm_context); l1337_assert_return_invoke(&result_object, &vm_context); + l1338_assert_return_invoke(&result_object, &vm_context); l1339_assert_return_invoke(&result_object, &vm_context); l1340_assert_return_invoke(&result_object, &vm_context); l1341_assert_return_invoke(&result_object, &vm_context); - l1342_assert_return_invoke(&result_object, &vm_context); + l1343_assert_return_invoke(&result_object, &vm_context); l1344_assert_return_invoke(&result_object, &vm_context); + l1345_assert_return_invoke(&result_object, &vm_context); l1346_assert_return_invoke(&result_object, &vm_context); l1347_assert_return_invoke(&result_object, &vm_context); l1349_assert_return_invoke(&result_object, &vm_context); l1350_assert_return_invoke(&result_object, &vm_context); l1351_assert_return_invoke(&result_object, &vm_context); - l1352_assert_return_invoke(&result_object, &vm_context); + l1353_assert_return_invoke(&result_object, &vm_context); l1354_assert_return_invoke(&result_object, &vm_context); + l1355_assert_return_invoke(&result_object, &vm_context); l1356_assert_return_invoke(&result_object, &vm_context); - l1357_assert_return_invoke(&result_object, &vm_context); + l1358_assert_return_invoke(&result_object, &vm_context); l1359_assert_return_invoke(&result_object, &vm_context); - l1361_assert_return_invoke(&result_object, &vm_context); + l1360_assert_return_invoke(&result_object, &vm_context); l1362_assert_return_invoke(&result_object, &vm_context); - l1364_assert_return_invoke(&result_object, &vm_context); + l1363_assert_return_invoke(&result_object, &vm_context); + l1365_assert_return_invoke(&result_object, &vm_context); l1366_assert_return_invoke(&result_object, &vm_context); + l1367_assert_return_invoke(&result_object, &vm_context); l1368_assert_return_invoke(&result_object, &vm_context); - l1369_assert_return_invoke(&result_object, &vm_context); l1370_assert_return_invoke(&result_object, &vm_context); - l1371_assert_return_invoke(&result_object, &vm_context); l1372_assert_return_invoke(&result_object, &vm_context); l1373_assert_return_invoke(&result_object, &vm_context); l1375_assert_return_invoke(&result_object, &vm_context); - l1376_assert_return_invoke(&result_object, &vm_context); l1377_assert_return_invoke(&result_object, &vm_context); l1378_assert_return_invoke(&result_object, &vm_context); - l1379_assert_return_invoke(&result_object, &vm_context); l1380_assert_return_invoke(&result_object, &vm_context); l1382_assert_return_invoke(&result_object, &vm_context); - l1383_assert_return_invoke(&result_object, &vm_context); l1384_assert_return_invoke(&result_object, &vm_context); l1385_assert_return_invoke(&result_object, &vm_context); l1386_assert_return_invoke(&result_object, &vm_context); l1387_assert_return_invoke(&result_object, &vm_context); + l1388_assert_return_invoke(&result_object, &vm_context); l1389_assert_return_invoke(&result_object, &vm_context); - l1390_assert_return_invoke(&result_object, &vm_context); l1391_assert_return_invoke(&result_object, &vm_context); l1392_assert_return_invoke(&result_object, &vm_context); l1393_assert_return_invoke(&result_object, &vm_context); l1394_assert_return_invoke(&result_object, &vm_context); + l1395_assert_return_invoke(&result_object, &vm_context); l1396_assert_return_invoke(&result_object, &vm_context); - l1397_assert_return_invoke(&result_object, &vm_context); l1398_assert_return_invoke(&result_object, &vm_context); l1399_assert_return_invoke(&result_object, &vm_context); l1400_assert_return_invoke(&result_object, &vm_context); l1401_assert_return_invoke(&result_object, &vm_context); + l1402_assert_return_invoke(&result_object, &vm_context); l1403_assert_return_invoke(&result_object, &vm_context); - l1404_assert_return_invoke(&result_object, &vm_context); l1405_assert_return_invoke(&result_object, &vm_context); l1406_assert_return_invoke(&result_object, &vm_context); l1407_assert_return_invoke(&result_object, &vm_context); l1408_assert_return_invoke(&result_object, &vm_context); + l1409_assert_return_invoke(&result_object, &vm_context); l1410_assert_return_invoke(&result_object, &vm_context); + l1412_assert_return_invoke(&result_object, &vm_context); + l1413_assert_return_invoke(&result_object, &vm_context); + l1414_assert_return_invoke(&result_object, &vm_context); + l1415_assert_return_invoke(&result_object, &vm_context); + l1416_assert_return_invoke(&result_object, &vm_context); + l1417_assert_return_invoke(&result_object, &vm_context); + l1419_assert_return_invoke(&result_object, &vm_context); + l1420_assert_return_invoke(&result_object, &vm_context); + l1421_assert_return_invoke(&result_object, &vm_context); + l1422_assert_return_invoke(&result_object, &vm_context); + l1423_assert_return_invoke(&result_object, &vm_context); + l1424_assert_return_invoke(&result_object, &vm_context); + l1426_assert_return_invoke(&result_object, &vm_context); } diff --git a/src/spectests/call.rs b/src/spectests/call.rs index a6ca414ab..de9c12f55 100644 --- a/src/spectests/call.rs +++ b/src/spectests/call.rs @@ -13,82 +13,83 @@ use wabt::wat2wasm; // Line 3 fn create_module_1() -> ResultObject { let module_str = "(module - (type (;0;) (func (result i32))) - (type (;1;) (func (result i64))) - (type (;2;) (func (result f32))) - (type (;3;) (func (result f64))) - (type (;4;) (func (param i32) (result i32))) - (type (;5;) (func (param i64) (result i64))) - (type (;6;) (func (param f32) (result f32))) - (type (;7;) (func (param f64) (result f64))) - (type (;8;) (func (param f32 i32) (result i32))) - (type (;9;) (func (param i32 i64) (result i64))) - (type (;10;) (func (param f64 f32) (result f32))) - (type (;11;) (func (param i64 f64) (result f64))) - (type (;12;) (func (param i64 i64) (result i64))) - (type (;13;) (func (param i64) (result i32))) - (type (;14;) (func)) - (func (;0;) (type 0) (result i32) + (type (;0;) (func (param i32 i32) (result i32))) + (type (;1;) (func (result i32))) + (type (;2;) (func (result i64))) + (type (;3;) (func (result f32))) + (type (;4;) (func (result f64))) + (type (;5;) (func (param i32) (result i32))) + (type (;6;) (func (param i64) (result i64))) + (type (;7;) (func (param f32) (result f32))) + (type (;8;) (func (param f64) (result f64))) + (type (;9;) (func (param f32 i32) (result i32))) + (type (;10;) (func (param i32 i64) (result i64))) + (type (;11;) (func (param f64 f32) (result f32))) + (type (;12;) (func (param i64 f64) (result f64))) + (type (;13;) (func (param i64 i64) (result i64))) + (type (;14;) (func (param i64) (result i32))) + (type (;15;) (func)) + (func (;0;) (type 1) (result i32) i32.const 306) - (func (;1;) (type 1) (result i64) + (func (;1;) (type 2) (result i64) i64.const 356) - (func (;2;) (type 2) (result f32) + (func (;2;) (type 3) (result f32) f32.const 0x1.e64p+11 (;=3890;)) - (func (;3;) (type 3) (result f64) + (func (;3;) (type 4) (result f64) f64.const 0x1.ec8p+11 (;=3940;)) - (func (;4;) (type 4) (param i32) (result i32) + (func (;4;) (type 5) (param i32) (result i32) get_local 0) - (func (;5;) (type 5) (param i64) (result i64) + (func (;5;) (type 6) (param i64) (result i64) get_local 0) - (func (;6;) (type 6) (param f32) (result f32) + (func (;6;) (type 7) (param f32) (result f32) get_local 0) - (func (;7;) (type 7) (param f64) (result f64) + (func (;7;) (type 8) (param f64) (result f64) get_local 0) - (func (;8;) (type 8) (param f32 i32) (result i32) + (func (;8;) (type 9) (param f32 i32) (result i32) get_local 1) - (func (;9;) (type 9) (param i32 i64) (result i64) + (func (;9;) (type 10) (param i32 i64) (result i64) get_local 1) - (func (;10;) (type 10) (param f64 f32) (result f32) + (func (;10;) (type 11) (param f64 f32) (result f32) get_local 1) - (func (;11;) (type 11) (param i64 f64) (result f64) + (func (;11;) (type 12) (param i64 f64) (result f64) get_local 1) - (func (;12;) (type 0) (result i32) + (func (;12;) (type 1) (result i32) call 0) - (func (;13;) (type 1) (result i64) + (func (;13;) (type 2) (result i64) call 1) - (func (;14;) (type 2) (result f32) + (func (;14;) (type 3) (result f32) call 2) - (func (;15;) (type 3) (result f64) + (func (;15;) (type 4) (result f64) call 3) - (func (;16;) (type 0) (result i32) + (func (;16;) (type 1) (result i32) i32.const 32 call 4) - (func (;17;) (type 1) (result i64) + (func (;17;) (type 2) (result i64) i64.const 64 call 5) - (func (;18;) (type 2) (result f32) + (func (;18;) (type 3) (result f32) f32.const 0x1.51eb86p+0 (;=1.32;) call 6) - (func (;19;) (type 3) (result f64) + (func (;19;) (type 4) (result f64) f64.const 0x1.a3d70a3d70a3dp+0 (;=1.64;) call 7) - (func (;20;) (type 0) (result i32) + (func (;20;) (type 1) (result i32) f32.const 0x1.00ccccp+5 (;=32.1;) i32.const 32 call 8) - (func (;21;) (type 1) (result i64) + (func (;21;) (type 2) (result i64) i32.const 32 i64.const 64 call 9) - (func (;22;) (type 2) (result f32) + (func (;22;) (type 3) (result f32) f64.const 0x1p+6 (;=64;) f32.const 0x1p+5 (;=32;) call 10) - (func (;23;) (type 3) (result f64) + (func (;23;) (type 4) (result f64) i64.const 64 f64.const 0x1.0066666666666p+6 (;=64.1;) call 11) - (func (;24;) (type 5) (param i64) (result i64) + (func (;24;) (type 6) (param i64) (result i64) get_local 0 i64.eqz if (result i64) ;; label = @1 @@ -101,7 +102,7 @@ fn create_module_1() -> ResultObject { call 24 i64.mul end) - (func (;25;) (type 12) (param i64 i64) (result i64) + (func (;25;) (type 13) (param i64 i64) (result i64) get_local 0 i64.eqz if (result i64) ;; label = @1 @@ -115,7 +116,7 @@ fn create_module_1() -> ResultObject { i64.mul call 25 end) - (func (;26;) (type 5) (param i64) (result i64) + (func (;26;) (type 6) (param i64) (result i64) get_local 0 i64.const 1 i64.le_u @@ -132,7 +133,7 @@ fn create_module_1() -> ResultObject { call 26 i64.add end) - (func (;27;) (type 13) (param i64) (result i32) + (func (;27;) (type 14) (param i64) (result i32) get_local 0 i64.eqz if (result i32) ;; label = @1 @@ -143,7 +144,7 @@ fn create_module_1() -> ResultObject { i64.sub call 28 end) - (func (;28;) (type 13) (param i64) (result i32) + (func (;28;) (type 14) (param i64) (result i32) get_local 0 i64.eqz if (result i32) ;; label = @1 @@ -154,12 +155,122 @@ fn create_module_1() -> ResultObject { i64.sub call 27 end) - (func (;29;) (type 14) + (func (;29;) (type 15) call 29) - (func (;30;) (type 14) + (func (;30;) (type 15) call 31) - (func (;31;) (type 14) + (func (;31;) (type 15) call 30) + (func (;32;) (type 1) (result i32) + call 0 + i32.const 2 + i32.const 3 + select) + (func (;33;) (type 1) (result i32) + i32.const 2 + call 0 + i32.const 3 + select) + (func (;34;) (type 1) (result i32) + i32.const 2 + i32.const 3 + call 0 + select) + (func (;35;) (type 1) (result i32) + call 0 + if (result i32) ;; label = @1 + i32.const 1 + else + i32.const 2 + end) + (func (;36;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 2 + br_if 0 (;@1;) + end) + (func (;37;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + call 0 + br_if 0 (;@1;) + end) + (func (;38;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 2 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;39;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + call 0 + br_table 0 (;@1;) 0 (;@1;) + end) + (func (;40;) (type 0) (param i32 i32) (result i32) + get_local 0) + (func (;41;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + i32.const 2 + i32.const 0 + call_indirect (type 0) + end) + (func (;42;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 2 + call 0 + i32.const 0 + call_indirect (type 0) + end) + (func (;43;) (type 1) (result i32) + block (result i32) ;; label = @1 + i32.const 1 + i32.const 2 + call 0 + call_indirect (type 0) + end) + (func (;44;) (type 15) + call 0 + i32.const 1 + i32.store) + (func (;45;) (type 15) + i32.const 10 + call 0 + i32.store) + (func (;46;) (type 1) (result i32) + call 0 + memory.grow) + (func (;47;) (type 1) (result i32) + call 0 + return) + (func (;48;) (type 15) + call 0 + drop) + (func (;49;) (type 1) (result i32) + block (result i32) ;; label = @1 + call 0 + br 0 (;@1;) + end) + (func (;50;) (type 1) (result i32) + (local i32) + call 0 + set_local 0 + get_local 0) + (func (;51;) (type 1) (result i32) + (local i32) + call 0 + tee_local 0) + (func (;52;) (type 1) (result i32) + call 0 + set_global 0 + get_global 0) + (func (;53;) (type 1) (result i32) + call 0 + i32.load) + (table (;0;) 1 1 anyfunc) + (memory (;0;) 1) + (global (;0;) (mut i32) (i32.const 10)) (export \"type-i32\" (func 12)) (export \"type-i64\" (func 13)) (export \"type-f32\" (func 14)) @@ -178,15 +289,37 @@ fn create_module_1() -> ResultObject { (export \"even\" (func 27)) (export \"odd\" (func 28)) (export \"runaway\" (func 29)) - (export \"mutual-runaway\" (func 30))) + (export \"mutual-runaway\" (func 30)) + (export \"as-select-first\" (func 32)) + (export \"as-select-mid\" (func 33)) + (export \"as-select-last\" (func 34)) + (export \"as-if-condition\" (func 35)) + (export \"as-br_if-first\" (func 36)) + (export \"as-br_if-last\" (func 37)) + (export \"as-br_table-first\" (func 38)) + (export \"as-br_table-last\" (func 39)) + (export \"as-call_indirect-first\" (func 41)) + (export \"as-call_indirect-mid\" (func 42)) + (export \"as-call_indirect-last\" (func 43)) + (export \"as-store-first\" (func 44)) + (export \"as-store-last\" (func 45)) + (export \"as-memory.grow-value\" (func 46)) + (export \"as-return-value\" (func 47)) + (export \"as-drop-operand\" (func 48)) + (export \"as-br-value\" (func 49)) + (export \"as-set_local-value\" (func 50)) + (export \"as-tee_local-value\" (func 51)) + (export \"as-set_global-value\" (func 52)) + (export \"as-load-operand\" (func 53)) + (elem (i32.const 0) 40)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") } -// Line 111 -fn l111_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l111_assert_return_invoke"); +// Line 202 +fn l202_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l202_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -196,9 +329,9 @@ fn l111_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 306 as i32); } -// Line 112 -fn l112_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l112_assert_return_invoke"); +// Line 203 +fn l203_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l203_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -208,9 +341,9 @@ fn l112_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 356 as i64); } -// Line 113 -fn l113_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l113_assert_return_invoke"); +// Line 204 +fn l204_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l204_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -220,9 +353,9 @@ fn l113_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3890.0 as f32); } -// Line 114 -fn l114_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l114_assert_return_invoke"); +// Line 205 +fn l205_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l205_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -232,9 +365,9 @@ fn l114_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3940.0 as f64); } -// Line 116 -fn l116_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l116_assert_return_invoke"); +// Line 207 +fn l207_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l207_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -244,9 +377,9 @@ fn l116_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32 as i32); } -// Line 117 -fn l117_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l117_assert_return_invoke"); +// Line 208 +fn l208_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l208_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -256,9 +389,9 @@ fn l117_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 64 as i64); } -// Line 118 -fn l118_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l118_assert_return_invoke"); +// Line 209 +fn l209_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l209_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -268,9 +401,9 @@ fn l118_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.32 as f32); } -// Line 119 -fn l119_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l119_assert_return_invoke"); +// Line 210 +fn l210_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l210_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -280,9 +413,9 @@ fn l119_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.64 as f64); } -// Line 121 -fn l121_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l121_assert_return_invoke"); +// Line 212 +fn l212_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l212_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -292,9 +425,9 @@ fn l121_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32 as i32); } -// Line 122 -fn l122_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l122_assert_return_invoke"); +// Line 213 +fn l213_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l213_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -304,9 +437,9 @@ fn l122_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 64 as i64); } -// Line 123 -fn l123_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l123_assert_return_invoke"); +// Line 214 +fn l214_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l214_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -316,9 +449,9 @@ fn l123_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32.0 as f32); } -// Line 124 -fn l124_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l124_assert_return_invoke"); +// Line 215 +fn l215_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l215_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -328,9 +461,9 @@ fn l124_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 64.1 as f64); } -// Line 126 -fn l126_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l126_assert_return_invoke"); +// Line 217 +fn l217_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l217_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -340,9 +473,9 @@ fn l126_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 127 -fn l127_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l127_assert_return_invoke"); +// Line 218 +fn l218_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l218_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -352,9 +485,9 @@ fn l127_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 128 -fn l128_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l128_assert_return_invoke"); +// Line 219 +fn l219_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l219_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -364,9 +497,9 @@ fn l128_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120 as i64); } -// Line 129 -fn l129_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l129_assert_return_invoke"); +// Line 220 +fn l220_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l220_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -376,9 +509,9 @@ fn l129_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 7034535277573963776 as i64); } -// Line 130 -fn l130_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l130_assert_return_invoke"); +// Line 221 +fn l221_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l221_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-acc") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -388,9 +521,9 @@ fn l130_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 131 -fn l131_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l131_assert_return_invoke"); +// Line 222 +fn l222_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l222_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-acc") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -400,9 +533,9 @@ fn l131_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 132 -fn l132_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l132_assert_return_invoke"); +// Line 223 +fn l223_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l223_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-acc") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -412,9 +545,9 @@ fn l132_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120 as i64); } -// Line 134 -fn l134_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l134_assert_return_invoke"); +// Line 225 +fn l225_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l225_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-acc") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -424,9 +557,9 @@ fn l134_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 7034535277573963776 as i64); } -// Line 138 -fn l138_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l138_assert_return_invoke"); +// Line 229 +fn l229_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l229_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -436,9 +569,9 @@ fn l138_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 139 -fn l139_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l139_assert_return_invoke"); +// Line 230 +fn l230_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l230_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -448,9 +581,9 @@ fn l139_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 140 -fn l140_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l140_assert_return_invoke"); +// Line 231 +fn l231_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l231_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -460,9 +593,9 @@ fn l140_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i64); } -// Line 141 -fn l141_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l141_assert_return_invoke"); +// Line 232 +fn l232_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l232_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -472,9 +605,9 @@ fn l141_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8 as i64); } -// Line 142 -fn l142_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l142_assert_return_invoke"); +// Line 233 +fn l233_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l233_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -484,9 +617,9 @@ fn l142_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10946 as i64); } -// Line 144 -fn l144_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l144_assert_return_invoke"); +// Line 235 +fn l235_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l235_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -496,9 +629,9 @@ fn l144_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 145 -fn l145_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l145_assert_return_invoke"); +// Line 236 +fn l236_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l236_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -508,9 +641,9 @@ fn l145_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 146 -fn l146_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l146_assert_return_invoke"); +// Line 237 +fn l237_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l237_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -520,9 +653,9 @@ fn l146_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 147 -fn l147_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l147_assert_return_invoke"); +// Line 238 +fn l238_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l238_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -532,9 +665,9 @@ fn l147_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 148 -fn l148_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l148_assert_return_invoke"); +// Line 239 +fn l239_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l239_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -544,9 +677,9 @@ fn l148_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 149 -fn l149_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l149_assert_return_invoke"); +// Line 240 +fn l240_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l240_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -556,9 +689,9 @@ fn l149_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 150 -fn l150_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l150_assert_return_invoke"); +// Line 241 +fn l241_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l241_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -568,9 +701,9 @@ fn l150_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 151 -fn l151_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l151_assert_return_invoke"); +// Line 242 +fn l242_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l242_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -580,101 +713,331 @@ fn l151_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 153 +// Line 244 -// Line 154 +// Line 245 -// Line 160 +// Line 247 +fn l247_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l247_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-select-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 248 +fn l248_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l248_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-select-mid") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + +// Line 249 +fn l249_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l249_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-select-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + +// Line 251 +fn l251_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l251_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-if-condition") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 253 +fn l253_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l253_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_if-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 254 +fn l254_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l254_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_if-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + +// Line 256 +fn l256_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l256_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_table-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 257 +fn l257_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l257_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br_table-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + +// Line 259 +fn l259_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l259_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-call_indirect-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 260 +fn l260_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l260_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-call_indirect-mid") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 2 as i32); +} + +// Line 261 + +// Line 263 +fn l263_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l263_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-store-first") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 264 +fn l264_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l264_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-store-last") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 267 +fn l267_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l267_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-return-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 268 +fn l268_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l268_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-drop-operand") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, ()); +} + +// Line 269 +fn l269_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l269_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-br-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 270 +fn l270_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l270_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 271 +fn l271_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l271_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 272 +fn l272_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l272_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 306 as i32); +} + +// Line 273 +fn l273_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l273_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-load-operand") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> i32 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1 as i32); +} + +// Line 278 #[test] -fn l160_assert_invalid() { +fn l278_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 10, 2, 5, 0, 16, 1, 69, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 167 +// Line 285 #[test] -fn l167_assert_invalid() { +fn l285_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 0, 1, 126, 3, 3, 2, 0, 1, 10, 12, 2, 5, 0, 16, 1, 69, 11, 4, 0, 66, 1, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 175 +// Line 293 #[test] -fn l175_assert_invalid() { +fn l293_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 0, 96, 1, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, 0, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 182 +// Line 300 #[test] -fn l182_assert_invalid() { +fn l300_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 9, 2, 4, 0, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 189 +// Line 307 #[test] -fn l189_assert_invalid() { +fn l307_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 11, 2, 6, 0, 65, 1, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 196 +// Line 314 #[test] -fn l196_assert_invalid() { +fn l314_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 3, 2, 0, 0, 10, 20, 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 204 +// Line 322 #[test] -fn l204_assert_invalid() { +fn l322_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, 2, 7, 0, 1, 65, 1, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 211 +// Line 329 #[test] -fn l211_assert_invalid() { +fn l329_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 127, 0, 3, 3, 2, 0, 1, 10, 12, 2, 7, 0, 65, 1, 1, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 218 +// Line 336 #[test] -fn l218_assert_invalid() { +fn l336_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 127, 124, 0, 3, 3, 2, 0, 1, 10, 20, 2, 15, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 225 +// Line 343 #[test] -fn l225_assert_invalid() { +fn l343_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 0, 0, 96, 2, 124, 127, 0, 3, 3, 2, 0, 1, 10, 20, 2, 15, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 16, 1, 11, 2, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 236 +// Line 354 #[test] -fn l236_assert_invalid() { +fn l354_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 6, 1, 4, 0, 16, 1, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 240 +// Line 358 #[test] -fn l240_assert_invalid() { +fn l358_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 10, 1, 8, 0, 16, 148, 152, 219, 226, 3, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); @@ -685,37 +1048,56 @@ fn test_module_1() { let result_object = create_module_1(); let vm_context = result_object.instance.generate_context(); // We group the calls together - l111_assert_return_invoke(&result_object, &vm_context); - l112_assert_return_invoke(&result_object, &vm_context); - l113_assert_return_invoke(&result_object, &vm_context); - l114_assert_return_invoke(&result_object, &vm_context); - l116_assert_return_invoke(&result_object, &vm_context); - l117_assert_return_invoke(&result_object, &vm_context); - l118_assert_return_invoke(&result_object, &vm_context); - l119_assert_return_invoke(&result_object, &vm_context); - l121_assert_return_invoke(&result_object, &vm_context); - l122_assert_return_invoke(&result_object, &vm_context); - l123_assert_return_invoke(&result_object, &vm_context); - l124_assert_return_invoke(&result_object, &vm_context); - l126_assert_return_invoke(&result_object, &vm_context); - l127_assert_return_invoke(&result_object, &vm_context); - l128_assert_return_invoke(&result_object, &vm_context); - l129_assert_return_invoke(&result_object, &vm_context); - l130_assert_return_invoke(&result_object, &vm_context); - l131_assert_return_invoke(&result_object, &vm_context); - l132_assert_return_invoke(&result_object, &vm_context); - l134_assert_return_invoke(&result_object, &vm_context); - l138_assert_return_invoke(&result_object, &vm_context); - l139_assert_return_invoke(&result_object, &vm_context); - l140_assert_return_invoke(&result_object, &vm_context); - l141_assert_return_invoke(&result_object, &vm_context); - l142_assert_return_invoke(&result_object, &vm_context); - l144_assert_return_invoke(&result_object, &vm_context); - l145_assert_return_invoke(&result_object, &vm_context); - l146_assert_return_invoke(&result_object, &vm_context); - l147_assert_return_invoke(&result_object, &vm_context); - l148_assert_return_invoke(&result_object, &vm_context); - l149_assert_return_invoke(&result_object, &vm_context); - l150_assert_return_invoke(&result_object, &vm_context); - l151_assert_return_invoke(&result_object, &vm_context); + l202_assert_return_invoke(&result_object, &vm_context); + l203_assert_return_invoke(&result_object, &vm_context); + l204_assert_return_invoke(&result_object, &vm_context); + l205_assert_return_invoke(&result_object, &vm_context); + l207_assert_return_invoke(&result_object, &vm_context); + l208_assert_return_invoke(&result_object, &vm_context); + l209_assert_return_invoke(&result_object, &vm_context); + l210_assert_return_invoke(&result_object, &vm_context); + l212_assert_return_invoke(&result_object, &vm_context); + l213_assert_return_invoke(&result_object, &vm_context); + l214_assert_return_invoke(&result_object, &vm_context); + l215_assert_return_invoke(&result_object, &vm_context); + l217_assert_return_invoke(&result_object, &vm_context); + l218_assert_return_invoke(&result_object, &vm_context); + l219_assert_return_invoke(&result_object, &vm_context); + l220_assert_return_invoke(&result_object, &vm_context); + l221_assert_return_invoke(&result_object, &vm_context); + l222_assert_return_invoke(&result_object, &vm_context); + l223_assert_return_invoke(&result_object, &vm_context); + l225_assert_return_invoke(&result_object, &vm_context); + l229_assert_return_invoke(&result_object, &vm_context); + l230_assert_return_invoke(&result_object, &vm_context); + l231_assert_return_invoke(&result_object, &vm_context); + l232_assert_return_invoke(&result_object, &vm_context); + l233_assert_return_invoke(&result_object, &vm_context); + l235_assert_return_invoke(&result_object, &vm_context); + l236_assert_return_invoke(&result_object, &vm_context); + l237_assert_return_invoke(&result_object, &vm_context); + l238_assert_return_invoke(&result_object, &vm_context); + l239_assert_return_invoke(&result_object, &vm_context); + l240_assert_return_invoke(&result_object, &vm_context); + l241_assert_return_invoke(&result_object, &vm_context); + l242_assert_return_invoke(&result_object, &vm_context); + l247_assert_return_invoke(&result_object, &vm_context); + l248_assert_return_invoke(&result_object, &vm_context); + l249_assert_return_invoke(&result_object, &vm_context); + l251_assert_return_invoke(&result_object, &vm_context); + l253_assert_return_invoke(&result_object, &vm_context); + l254_assert_return_invoke(&result_object, &vm_context); + l256_assert_return_invoke(&result_object, &vm_context); + l257_assert_return_invoke(&result_object, &vm_context); + l259_assert_return_invoke(&result_object, &vm_context); + l260_assert_return_invoke(&result_object, &vm_context); + l263_assert_return_invoke(&result_object, &vm_context); + l264_assert_return_invoke(&result_object, &vm_context); + l267_assert_return_invoke(&result_object, &vm_context); + l268_assert_return_invoke(&result_object, &vm_context); + l269_assert_return_invoke(&result_object, &vm_context); + l270_assert_return_invoke(&result_object, &vm_context); + l271_assert_return_invoke(&result_object, &vm_context); + l272_assert_return_invoke(&result_object, &vm_context); + l273_assert_return_invoke(&result_object, &vm_context); } diff --git a/src/spectests/call_indirect.rs b/src/spectests/call_indirect.rs index c97abcff9..bf553980e 100644 --- a/src/spectests/call_indirect.rs +++ b/src/spectests/call_indirect.rs @@ -440,12 +440,25 @@ fn create_module_1() -> ResultObject { call_indirect (type 8) set_local 0 get_local 0) - (func (;63;) (type 1) (result i32) + (func (;63;) (type 4) (result f64) + (local f64) + f64.const 0x1p+0 (;=1;) + i32.const 7 + call_indirect (type 8) + tee_local 0) + (func (;64;) (type 4) (result f64) + f64.const 0x1p+0 (;=1;) + i32.const 7 + call_indirect (type 8) + set_global 0 + get_global 0) + (func (;65;) (type 1) (result i32) i32.const 0 call_indirect (type 1) i32.load) (table (;0;) 29 29 anyfunc) (memory (;0;) 1) + (global (;0;) (mut f64) (f64.const 0x1.4p+3 (;=10;))) (export \"type-i32\" (func 17)) (export \"type-i64\" (func 18)) (export \"type-f32\" (func 19)) @@ -491,16 +504,18 @@ fn create_module_1() -> ResultObject { (export \"as-drop-operand\" (func 60)) (export \"as-br-value\" (func 61)) (export \"as-set_local-value\" (func 62)) - (export \"as-load-operand\" (func 63)) + (export \"as-tee_local-value\" (func 63)) + (export \"as-set_global-value\" (func 64)) + (export \"as-load-operand\" (func 65)) (elem (i32.const 0) 0 1 2 3 4 5 6 7 10 8 11 9 35 36 43 44 45 46 47 12 13 14 15 37 38 39 40 41 42)) "; let wasm_binary = wat2wasm(module_str.as_bytes()).expect("WAST not valid or malformed"); instantiate(wasm_binary, spectest_importobject()).expect("WASM can't be instantiated") } -// Line 379 -fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l379_assert_return_invoke"); +// Line 388 +fn l388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l388_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -510,9 +525,9 @@ fn l379_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 306 as i32); } -// Line 380 -fn l380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l380_assert_return_invoke"); +// Line 389 +fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l389_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -522,9 +537,9 @@ fn l380_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 356 as i64); } -// Line 381 -fn l381_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l381_assert_return_invoke"); +// Line 390 +fn l390_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l390_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -534,9 +549,9 @@ fn l381_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3890.0 as f32); } -// Line 382 -fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l382_assert_return_invoke"); +// Line 391 +fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l391_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -546,9 +561,9 @@ fn l382_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3940.0 as f64); } -// Line 384 -fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l384_assert_return_invoke"); +// Line 393 +fn l393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l393_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-index") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -558,9 +573,9 @@ fn l384_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 100 as i64); } -// Line 386 -fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l386_assert_return_invoke"); +// Line 395 +fn l395_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l395_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -570,9 +585,9 @@ fn l386_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32 as i32); } -// Line 387 -fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l387_assert_return_invoke"); +// Line 396 +fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l396_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -582,9 +597,9 @@ fn l387_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 64 as i64); } -// Line 388 -fn l388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l388_assert_return_invoke"); +// Line 397 +fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l397_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -594,9 +609,9 @@ fn l388_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.32 as f32); } -// Line 389 -fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l389_assert_return_invoke"); +// Line 398 +fn l398_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l398_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-first-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -606,9 +621,9 @@ fn l389_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.64 as f64); } -// Line 391 -fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l391_assert_return_invoke"); +// Line 400 +fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l400_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -618,9 +633,9 @@ fn l391_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32 as i32); } -// Line 392 -fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l392_assert_return_invoke"); +// Line 401 +fn l401_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l401_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -630,9 +645,9 @@ fn l392_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 64 as i64); } -// Line 393 -fn l393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l393_assert_return_invoke"); +// Line 402 +fn l402_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l402_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -642,9 +657,9 @@ fn l393_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 32.0 as f32); } -// Line 394 -fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l394_assert_return_invoke"); +// Line 403 +fn l403_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l403_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("type-second-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -654,9 +669,9 @@ fn l394_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 64.1 as f64); } -// Line 396 -fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l396_assert_return_invoke"); +// Line 405 +fn l405_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l405_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -666,9 +681,9 @@ fn l396_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i64); } -// Line 397 -fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l397_assert_return_invoke"); +// Line 406 +fn l406_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l406_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -678,9 +693,9 @@ fn l397_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 5 as i64); } -// Line 398 -fn l398_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l398_assert_return_invoke"); +// Line 407 +fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l407_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -690,9 +705,9 @@ fn l398_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120 as i64); } -// Line 399 -fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l399_assert_return_invoke"); +// Line 408 +fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l408_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -702,9 +717,9 @@ fn l399_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8 as i64); } -// Line 400 -fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l400_assert_return_invoke"); +// Line 409 +fn l409_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l409_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -714,19 +729,19 @@ fn l400_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i64); } -// Line 401 +// Line 410 -// Line 402 +// Line 411 -// Line 403 +// Line 412 -// Line 404 +// Line 413 -// Line 405 +// Line 414 -// Line 407 -fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l407_assert_return_invoke"); +// Line 416 +fn l416_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l416_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -736,9 +751,9 @@ fn l407_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i64); } -// Line 408 -fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l408_assert_return_invoke"); +// Line 417 +fn l417_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l417_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -748,9 +763,9 @@ fn l408_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 362880 as i64); } -// Line 409 -fn l409_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l409_assert_return_invoke"); +// Line 418 +fn l418_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l418_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -760,9 +775,9 @@ fn l409_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 55 as i64); } -// Line 410 -fn l410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l410_assert_return_invoke"); +// Line 419 +fn l419_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l419_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -772,13 +787,13 @@ fn l410_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i64); } -// Line 411 +// Line 420 -// Line 412 +// Line 421 -// Line 414 -fn l414_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l414_assert_return_invoke"); +// Line 423 +fn l423_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l423_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -788,9 +803,9 @@ fn l414_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 415 -fn l415_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l415_assert_return_invoke"); +// Line 424 +fn l424_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l424_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -800,9 +815,9 @@ fn l415_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 362880 as i32); } -// Line 416 -fn l416_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l416_assert_return_invoke"); +// Line 425 +fn l425_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l425_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -812,9 +827,9 @@ fn l416_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 55 as i32); } -// Line 417 -fn l417_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l417_assert_return_invoke"); +// Line 426 +fn l426_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l426_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -824,13 +839,13 @@ fn l417_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9 as i32); } -// Line 418 +// Line 427 -// Line 419 +// Line 428 -// Line 421 -fn l421_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l421_assert_return_invoke"); +// Line 430 +fn l430_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l430_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -840,9 +855,9 @@ fn l421_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9.0 as f32); } -// Line 422 -fn l422_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l422_assert_return_invoke"); +// Line 431 +fn l431_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l431_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -852,9 +867,9 @@ fn l422_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 362880.0 as f32); } -// Line 423 -fn l423_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l423_assert_return_invoke"); +// Line 432 +fn l432_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l432_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -864,9 +879,9 @@ fn l423_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 55.0 as f32); } -// Line 424 -fn l424_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l424_assert_return_invoke"); +// Line 433 +fn l433_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l433_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -876,13 +891,13 @@ fn l424_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9.0 as f32); } -// Line 425 +// Line 434 -// Line 426 +// Line 435 -// Line 428 -fn l428_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l428_assert_return_invoke"); +// Line 437 +fn l437_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l437_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -892,9 +907,9 @@ fn l428_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9.0 as f64); } -// Line 429 -fn l429_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l429_assert_return_invoke"); +// Line 438 +fn l438_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l438_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -904,9 +919,9 @@ fn l429_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 362880.0 as f64); } -// Line 430 -fn l430_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l430_assert_return_invoke"); +// Line 439 +fn l439_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l439_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -916,9 +931,9 @@ fn l430_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 55.0 as f64); } -// Line 431 -fn l431_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l431_assert_return_invoke"); +// Line 440 +fn l440_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l440_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("dispatch-structural-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -928,13 +943,13 @@ fn l431_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 9.0 as f64); } -// Line 432 +// Line 441 -// Line 433 +// Line 442 -// Line 435 -fn l435_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l435_assert_return_invoke"); +// Line 444 +fn l444_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l444_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -944,9 +959,9 @@ fn l435_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 436 -fn l436_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l436_assert_return_invoke"); +// Line 445 +fn l445_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l445_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -956,9 +971,9 @@ fn l436_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 437 -fn l437_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l437_assert_return_invoke"); +// Line 446 +fn l446_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l446_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -968,9 +983,9 @@ fn l437_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120 as i64); } -// Line 438 -fn l438_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l438_assert_return_invoke"); +// Line 447 +fn l447_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l447_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -980,9 +995,9 @@ fn l438_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 7034535277573963776 as i64); } -// Line 440 -fn l440_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l440_assert_return_invoke"); +// Line 449 +fn l449_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l449_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -992,9 +1007,9 @@ fn l440_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 441 -fn l441_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l441_assert_return_invoke"); +// Line 450 +fn l450_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l450_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1004,9 +1019,9 @@ fn l441_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 442 -fn l442_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l442_assert_return_invoke"); +// Line 451 +fn l451_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l451_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1016,9 +1031,9 @@ fn l442_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120 as i32); } -// Line 443 -fn l443_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l443_assert_return_invoke"); +// Line 452 +fn l452_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l452_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1028,9 +1043,9 @@ fn l443_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3628800 as i32); } -// Line 445 -fn l445_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l445_assert_return_invoke"); +// Line 454 +fn l454_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l454_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1040,9 +1055,9 @@ fn l445_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f32); } -// Line 446 -fn l446_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l446_assert_return_invoke"); +// Line 455 +fn l455_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l455_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1052,9 +1067,9 @@ fn l446_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f32); } -// Line 447 -fn l447_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l447_assert_return_invoke"); +// Line 456 +fn l456_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l456_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1064,9 +1079,9 @@ fn l447_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120.0 as f32); } -// Line 448 -fn l448_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l448_assert_return_invoke"); +// Line 457 +fn l457_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l457_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1076,9 +1091,9 @@ fn l448_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3628800.0 as f32); } -// Line 450 -fn l450_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l450_assert_return_invoke"); +// Line 459 +fn l459_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l459_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1088,9 +1103,9 @@ fn l450_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f64); } -// Line 451 -fn l451_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l451_assert_return_invoke"); +// Line 460 +fn l460_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l460_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1100,9 +1115,9 @@ fn l451_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f64); } -// Line 452 -fn l452_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l452_assert_return_invoke"); +// Line 461 +fn l461_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l461_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1112,9 +1127,9 @@ fn l452_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 120.0 as f64); } -// Line 453 -fn l453_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l453_assert_return_invoke"); +// Line 462 +fn l462_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l462_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fac-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1124,9 +1139,9 @@ fn l453_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3628800.0 as f64); } -// Line 455 -fn l455_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l455_assert_return_invoke"); +// Line 464 +fn l464_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l464_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1136,9 +1151,9 @@ fn l455_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 456 -fn l456_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l456_assert_return_invoke"); +// Line 465 +fn l465_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l465_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1148,9 +1163,9 @@ fn l456_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i64); } -// Line 457 -fn l457_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l457_assert_return_invoke"); +// Line 466 +fn l466_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l466_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1160,9 +1175,9 @@ fn l457_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i64); } -// Line 458 -fn l458_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l458_assert_return_invoke"); +// Line 467 +fn l467_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l467_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1172,9 +1187,9 @@ fn l458_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8 as i64); } -// Line 459 -fn l459_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l459_assert_return_invoke"); +// Line 468 +fn l468_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l468_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1184,9 +1199,9 @@ fn l459_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10946 as i64); } -// Line 461 -fn l461_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l461_assert_return_invoke"); +// Line 470 +fn l470_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l470_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1196,9 +1211,9 @@ fn l461_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 462 -fn l462_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l462_assert_return_invoke"); +// Line 471 +fn l471_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l471_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1208,9 +1223,9 @@ fn l462_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 463 -fn l463_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l463_assert_return_invoke"); +// Line 472 +fn l472_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l472_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1220,9 +1235,9 @@ fn l463_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 464 -fn l464_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l464_assert_return_invoke"); +// Line 473 +fn l473_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l473_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1232,9 +1247,9 @@ fn l464_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8 as i32); } -// Line 465 -fn l465_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l465_assert_return_invoke"); +// Line 474 +fn l474_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l474_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-i32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1244,9 +1259,9 @@ fn l465_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10946 as i32); } -// Line 467 -fn l467_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l467_assert_return_invoke"); +// Line 476 +fn l476_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l476_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1256,9 +1271,9 @@ fn l467_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f32); } -// Line 468 -fn l468_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l468_assert_return_invoke"); +// Line 477 +fn l477_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l477_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1268,9 +1283,9 @@ fn l468_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f32); } -// Line 469 -fn l469_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l469_assert_return_invoke"); +// Line 478 +fn l478_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l478_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1280,9 +1295,9 @@ fn l469_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2.0 as f32); } -// Line 470 -fn l470_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l470_assert_return_invoke"); +// Line 479 +fn l479_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l479_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1292,9 +1307,9 @@ fn l470_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8.0 as f32); } -// Line 471 -fn l471_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l471_assert_return_invoke"); +// Line 480 +fn l480_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l480_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f32") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1304,9 +1319,9 @@ fn l471_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10946.0 as f32); } -// Line 473 -fn l473_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l473_assert_return_invoke"); +// Line 482 +fn l482_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l482_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1316,9 +1331,9 @@ fn l473_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f64); } -// Line 474 -fn l474_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l474_assert_return_invoke"); +// Line 483 +fn l483_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l483_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1328,9 +1343,9 @@ fn l474_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f64); } -// Line 475 -fn l475_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l475_assert_return_invoke"); +// Line 484 +fn l484_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l484_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1340,9 +1355,9 @@ fn l475_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2.0 as f64); } -// Line 476 -fn l476_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l476_assert_return_invoke"); +// Line 485 +fn l485_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l485_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1352,9 +1367,9 @@ fn l476_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 8.0 as f64); } -// Line 477 -fn l477_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l477_assert_return_invoke"); +// Line 486 +fn l486_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l486_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("fib-f64") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1364,9 +1379,9 @@ fn l477_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 10946.0 as f64); } -// Line 479 -fn l479_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l479_assert_return_invoke"); +// Line 488 +fn l488_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l488_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1376,9 +1391,9 @@ fn l479_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 480 -fn l480_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l480_assert_return_invoke"); +// Line 489 +fn l489_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l489_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1388,9 +1403,9 @@ fn l480_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 481 -fn l481_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l481_assert_return_invoke"); +// Line 490 +fn l490_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l490_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1400,9 +1415,9 @@ fn l481_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 482 -fn l482_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l482_assert_return_invoke"); +// Line 491 +fn l491_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l491_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("even") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1412,9 +1427,9 @@ fn l482_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 483 -fn l483_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l483_assert_return_invoke"); +// Line 492 +fn l492_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l492_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1424,9 +1439,9 @@ fn l483_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 484 -fn l484_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l484_assert_return_invoke"); +// Line 493 +fn l493_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l493_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1436,9 +1451,9 @@ fn l484_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 485 -fn l485_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l485_assert_return_invoke"); +// Line 494 +fn l494_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l494_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1448,9 +1463,9 @@ fn l485_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 99 as i32); } -// Line 486 -fn l486_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l486_assert_return_invoke"); +// Line 495 +fn l495_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l495_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("odd") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1460,13 +1475,13 @@ fn l486_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 44 as i32); } -// Line 488 +// Line 497 -// Line 489 +// Line 498 -// Line 491 -fn l491_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l491_assert_return_invoke"); +// Line 500 +fn l500_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l500_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1476,9 +1491,9 @@ fn l491_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 306 as i32); } -// Line 492 -fn l492_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l492_assert_return_invoke"); +// Line 501 +fn l501_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l501_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-mid") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1488,9 +1503,9 @@ fn l492_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 493 -fn l493_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l493_assert_return_invoke"); +// Line 502 +fn l502_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l502_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-select-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1500,9 +1515,9 @@ fn l493_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 495 -fn l495_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l495_assert_return_invoke"); +// Line 504 +fn l504_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l504_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-if-condition") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1512,9 +1527,9 @@ fn l495_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 497 -fn l497_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l497_assert_return_invoke"); +// Line 506 +fn l506_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l506_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1524,9 +1539,9 @@ fn l497_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 356 as i64); } -// Line 498 -fn l498_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l498_assert_return_invoke"); +// Line 507 +fn l507_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l507_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_if-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1536,9 +1551,9 @@ fn l498_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 500 -fn l500_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l500_assert_return_invoke"); +// Line 509 +fn l509_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l509_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1548,9 +1563,9 @@ fn l500_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 3890.0 as f32); } -// Line 501 -fn l501_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l501_assert_return_invoke"); +// Line 510 +fn l510_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l510_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br_table-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1560,9 +1575,9 @@ fn l501_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 2 as i32); } -// Line 503 -fn l503_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l503_assert_return_invoke"); +// Line 512 +fn l512_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l512_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-store-first") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1572,9 +1587,9 @@ fn l503_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 504 -fn l504_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l504_assert_return_invoke"); +// Line 513 +fn l513_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l513_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-store-last") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1584,9 +1599,9 @@ fn l504_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 507 -fn l507_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l507_assert_return_invoke"); +// Line 516 +fn l516_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l516_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-return-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1596,9 +1611,9 @@ fn l507_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 508 -fn l508_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l508_assert_return_invoke"); +// Line 517 +fn l517_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l517_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-drop-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1608,9 +1623,9 @@ fn l508_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, ()); } -// Line 509 -fn l509_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l509_assert_return_invoke"); +// Line 518 +fn l518_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l518_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-br-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1620,9 +1635,9 @@ fn l509_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f32); } -// Line 510 -fn l510_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l510_assert_return_invoke"); +// Line 519 +fn l519_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l519_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-set_local-value") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1632,9 +1647,33 @@ fn l510_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1.0 as f64); } -// Line 511 -fn l511_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { - println!("Executing function {}", "l511_assert_return_invoke"); +// Line 520 +fn l520_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l520_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-tee_local-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 521 +fn l521_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l521_assert_return_invoke"); + let func_index = match result_object.module.info.exports.get("as-set_global-value") { + Some(&Export::Function(index)) => index, + _ => panic!("Function not found"), + }; + let invoke_fn: fn(&VmCtx) -> f64 = get_instance_function!(result_object.instance, func_index); + let result = invoke_fn(&vm_context); + assert_eq!(result, 1.0 as f64); +} + +// Line 522 +fn l522_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { + println!("Executing function {}", "l522_assert_return_invoke"); let func_index = match result_object.module.info.exports.get("as-load-operand") { Some(&Export::Function(index)) => index, _ => panic!("Function not found"), @@ -1644,217 +1683,217 @@ fn l511_assert_return_invoke(result_object: &ResultObject, vm_context: &VmCtx) { assert_eq!(result, 1 as i32); } -// Line 516 +// Line 527 #[test] -fn l516_assert_malformed() { +fn l527_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 528 +// Line 539 #[test] -fn l528_assert_malformed() { +fn l539_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 540 +// Line 551 #[test] -fn l540_assert_malformed() { +fn l551_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 552 +// Line 563 #[test] -fn l552_assert_malformed() { +fn l563_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 564 +// Line 575 #[test] -fn l564_assert_malformed() { +fn l575_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 576 +// Line 587 #[test] -fn l576_assert_malformed() { +fn l587_assert_malformed() { let wasm_binary = [40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 586 +// Line 597 #[test] -fn l586_assert_malformed() { +fn l597_assert_malformed() { let wasm_binary = [40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 112, 97, 114, 97, 109, 32, 36, 120, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 593 +// Line 604 #[test] -fn l593_assert_malformed() { +fn l604_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 603 +// Line 614 #[test] -fn l603_assert_malformed() { +fn l614_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 613 +// Line 624 #[test] -fn l613_assert_malformed() { +fn l624_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 623 +// Line 634 #[test] -fn l623_assert_malformed() { +fn l634_assert_malformed() { let wasm_binary = [40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 32, 40, 102, 117, 110, 99, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 41, 41, 40, 116, 97, 98, 108, 101, 32, 48, 32, 97, 110, 121, 102, 117, 110, 99, 41, 40, 102, 117, 110, 99, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 40, 99, 97, 108, 108, 95, 105, 110, 100, 105, 114, 101, 99, 116, 32, 40, 116, 121, 112, 101, 32, 36, 115, 105, 103, 41, 32, 40, 112, 97, 114, 97, 109, 32, 105, 51, 50, 41, 32, 40, 114, 101, 115, 117, 108, 116, 32, 105, 51, 50, 41, 32, 32, 32, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 40, 105, 51, 50, 46, 99, 111, 110, 115, 116, 32, 48, 41, 32, 32, 41, 41]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is malformed"); } -// Line 638 +// Line 649 #[test] -fn l638_assert_invalid() { +fn l649_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 4, 1, 96, 0, 0, 3, 2, 1, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 646 +// Line 657 #[test] -fn l646_assert_invalid() { +fn l657_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, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 654 +// Line 665 #[test] -fn l654_assert_invalid() { +fn l665_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 0, 1, 126, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 0, 17, 0, 0, 69, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 663 +// Line 674 #[test] -fn l663_assert_invalid() { +fn l674_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 671 +// Line 682 #[test] -fn l671_assert_invalid() { +fn l682_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 9, 1, 7, 0, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 679 +// Line 690 #[test] -fn l679_assert_invalid() { +fn l690_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, 10, 11, 1, 9, 0, 65, 1, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 687 -#[test] -fn l687_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, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 65, 0, 17, 0, 0, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - // Line 698 #[test] fn l698_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, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 0, 64, 65, 1, 65, 0, 17, 0, 0, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 709 +#[test] +fn l709_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 10, 1, 8, 0, 65, 1, 1, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 706 +// Line 717 #[test] -fn l706_assert_invalid() { +fn l717_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 8, 2, 96, 1, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 11, 1, 9, 0, 65, 0, 66, 1, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 715 +// Line 726 #[test] -fn l715_assert_invalid() { +fn l726_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 12, 1, 10, 0, 1, 65, 1, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 725 +// Line 736 #[test] -fn l725_assert_invalid() { +fn l736_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 12, 1, 10, 0, 65, 1, 1, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 735 +// Line 746 #[test] -fn l735_assert_invalid() { +fn l746_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 127, 124, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 1, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 745 +// Line 756 #[test] -fn l745_assert_invalid() { +fn l756_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 1, 9, 2, 96, 2, 124, 127, 0, 96, 0, 0, 3, 2, 1, 1, 4, 4, 1, 112, 0, 0, 10, 20, 1, 18, 0, 65, 1, 68, 0, 0, 0, 0, 0, 0, 240, 63, 65, 0, 17, 0, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 759 +// Line 770 #[test] -fn l759_assert_invalid() { +fn l770_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, 10, 9, 1, 7, 0, 65, 0, 17, 1, 0, 11]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); } -// Line 766 -#[test] -fn l766_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, 10, 13, 1, 11, 0, 65, 0, 17, 148, 152, 219, 226, 3, 0, 11]; - let compilation = compile(wasm_binary.to_vec()); - assert!(compilation.is_err(), "WASM should not compile as is invalid"); -} - // Line 777 #[test] fn l777_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, 10, 13, 1, 11, 0, 65, 0, 17, 148, 152, 219, 226, 3, 0, 11]; + let compilation = compile(wasm_binary.to_vec()); + assert!(compilation.is_err(), "WASM should not compile as is invalid"); +} + +// Line 788 +#[test] +fn l788_assert_invalid() { let wasm_binary = [0, 97, 115, 109, 1, 0, 0, 0, 4, 5, 1, 112, 1, 2, 2, 9, 8, 1, 0, 65, 0, 11, 2, 0, 0]; let compilation = compile(wasm_binary.to_vec()); assert!(compilation.is_err(), "WASM should not compile as is invalid"); @@ -1865,97 +1904,99 @@ fn test_module_1() { let result_object = create_module_1(); let vm_context = result_object.instance.generate_context(); // We group the calls together - l379_assert_return_invoke(&result_object, &vm_context); - l380_assert_return_invoke(&result_object, &vm_context); - l381_assert_return_invoke(&result_object, &vm_context); - l382_assert_return_invoke(&result_object, &vm_context); - l384_assert_return_invoke(&result_object, &vm_context); - l386_assert_return_invoke(&result_object, &vm_context); - l387_assert_return_invoke(&result_object, &vm_context); l388_assert_return_invoke(&result_object, &vm_context); l389_assert_return_invoke(&result_object, &vm_context); + l390_assert_return_invoke(&result_object, &vm_context); l391_assert_return_invoke(&result_object, &vm_context); - l392_assert_return_invoke(&result_object, &vm_context); l393_assert_return_invoke(&result_object, &vm_context); - l394_assert_return_invoke(&result_object, &vm_context); + l395_assert_return_invoke(&result_object, &vm_context); l396_assert_return_invoke(&result_object, &vm_context); l397_assert_return_invoke(&result_object, &vm_context); l398_assert_return_invoke(&result_object, &vm_context); - l399_assert_return_invoke(&result_object, &vm_context); l400_assert_return_invoke(&result_object, &vm_context); + l401_assert_return_invoke(&result_object, &vm_context); + l402_assert_return_invoke(&result_object, &vm_context); + l403_assert_return_invoke(&result_object, &vm_context); + l405_assert_return_invoke(&result_object, &vm_context); + l406_assert_return_invoke(&result_object, &vm_context); l407_assert_return_invoke(&result_object, &vm_context); l408_assert_return_invoke(&result_object, &vm_context); l409_assert_return_invoke(&result_object, &vm_context); - l410_assert_return_invoke(&result_object, &vm_context); - l414_assert_return_invoke(&result_object, &vm_context); - l415_assert_return_invoke(&result_object, &vm_context); l416_assert_return_invoke(&result_object, &vm_context); l417_assert_return_invoke(&result_object, &vm_context); - l421_assert_return_invoke(&result_object, &vm_context); - l422_assert_return_invoke(&result_object, &vm_context); + l418_assert_return_invoke(&result_object, &vm_context); + l419_assert_return_invoke(&result_object, &vm_context); l423_assert_return_invoke(&result_object, &vm_context); l424_assert_return_invoke(&result_object, &vm_context); - l428_assert_return_invoke(&result_object, &vm_context); - l429_assert_return_invoke(&result_object, &vm_context); + l425_assert_return_invoke(&result_object, &vm_context); + l426_assert_return_invoke(&result_object, &vm_context); l430_assert_return_invoke(&result_object, &vm_context); l431_assert_return_invoke(&result_object, &vm_context); - l435_assert_return_invoke(&result_object, &vm_context); - l436_assert_return_invoke(&result_object, &vm_context); + l432_assert_return_invoke(&result_object, &vm_context); + l433_assert_return_invoke(&result_object, &vm_context); l437_assert_return_invoke(&result_object, &vm_context); l438_assert_return_invoke(&result_object, &vm_context); + l439_assert_return_invoke(&result_object, &vm_context); l440_assert_return_invoke(&result_object, &vm_context); - l441_assert_return_invoke(&result_object, &vm_context); - l442_assert_return_invoke(&result_object, &vm_context); - l443_assert_return_invoke(&result_object, &vm_context); + l444_assert_return_invoke(&result_object, &vm_context); l445_assert_return_invoke(&result_object, &vm_context); l446_assert_return_invoke(&result_object, &vm_context); l447_assert_return_invoke(&result_object, &vm_context); - l448_assert_return_invoke(&result_object, &vm_context); + l449_assert_return_invoke(&result_object, &vm_context); l450_assert_return_invoke(&result_object, &vm_context); l451_assert_return_invoke(&result_object, &vm_context); l452_assert_return_invoke(&result_object, &vm_context); - l453_assert_return_invoke(&result_object, &vm_context); + l454_assert_return_invoke(&result_object, &vm_context); l455_assert_return_invoke(&result_object, &vm_context); l456_assert_return_invoke(&result_object, &vm_context); l457_assert_return_invoke(&result_object, &vm_context); - l458_assert_return_invoke(&result_object, &vm_context); l459_assert_return_invoke(&result_object, &vm_context); + l460_assert_return_invoke(&result_object, &vm_context); l461_assert_return_invoke(&result_object, &vm_context); l462_assert_return_invoke(&result_object, &vm_context); - l463_assert_return_invoke(&result_object, &vm_context); l464_assert_return_invoke(&result_object, &vm_context); l465_assert_return_invoke(&result_object, &vm_context); + l466_assert_return_invoke(&result_object, &vm_context); l467_assert_return_invoke(&result_object, &vm_context); l468_assert_return_invoke(&result_object, &vm_context); - l469_assert_return_invoke(&result_object, &vm_context); l470_assert_return_invoke(&result_object, &vm_context); l471_assert_return_invoke(&result_object, &vm_context); + l472_assert_return_invoke(&result_object, &vm_context); l473_assert_return_invoke(&result_object, &vm_context); l474_assert_return_invoke(&result_object, &vm_context); - l475_assert_return_invoke(&result_object, &vm_context); l476_assert_return_invoke(&result_object, &vm_context); l477_assert_return_invoke(&result_object, &vm_context); + l478_assert_return_invoke(&result_object, &vm_context); l479_assert_return_invoke(&result_object, &vm_context); l480_assert_return_invoke(&result_object, &vm_context); - l481_assert_return_invoke(&result_object, &vm_context); l482_assert_return_invoke(&result_object, &vm_context); l483_assert_return_invoke(&result_object, &vm_context); l484_assert_return_invoke(&result_object, &vm_context); l485_assert_return_invoke(&result_object, &vm_context); l486_assert_return_invoke(&result_object, &vm_context); + l488_assert_return_invoke(&result_object, &vm_context); + l489_assert_return_invoke(&result_object, &vm_context); + l490_assert_return_invoke(&result_object, &vm_context); l491_assert_return_invoke(&result_object, &vm_context); l492_assert_return_invoke(&result_object, &vm_context); l493_assert_return_invoke(&result_object, &vm_context); + l494_assert_return_invoke(&result_object, &vm_context); l495_assert_return_invoke(&result_object, &vm_context); - l497_assert_return_invoke(&result_object, &vm_context); - l498_assert_return_invoke(&result_object, &vm_context); l500_assert_return_invoke(&result_object, &vm_context); l501_assert_return_invoke(&result_object, &vm_context); - l503_assert_return_invoke(&result_object, &vm_context); + l502_assert_return_invoke(&result_object, &vm_context); l504_assert_return_invoke(&result_object, &vm_context); + l506_assert_return_invoke(&result_object, &vm_context); l507_assert_return_invoke(&result_object, &vm_context); - l508_assert_return_invoke(&result_object, &vm_context); l509_assert_return_invoke(&result_object, &vm_context); l510_assert_return_invoke(&result_object, &vm_context); - l511_assert_return_invoke(&result_object, &vm_context); + l512_assert_return_invoke(&result_object, &vm_context); + l513_assert_return_invoke(&result_object, &vm_context); + l516_assert_return_invoke(&result_object, &vm_context); + l517_assert_return_invoke(&result_object, &vm_context); + l518_assert_return_invoke(&result_object, &vm_context); + l519_assert_return_invoke(&result_object, &vm_context); + l520_assert_return_invoke(&result_object, &vm_context); + l521_assert_return_invoke(&result_object, &vm_context); + l522_assert_return_invoke(&result_object, &vm_context); } diff --git a/src/webassembly/memory.rs b/src/webassembly/memory.rs index 0dac6aaf3..7df7dc802 100644 --- a/src/webassembly/memory.rs +++ b/src/webassembly/memory.rs @@ -15,7 +15,7 @@ const MAX_PAGES: u32 = 65536; /// This linear memory has a stable base address and at the same time allows /// for dynamical growing. pub struct LinearMemory { - mmap: MmapMut, + pub mmap: MmapMut, // The initial size of the WebAssembly Memory, in units of // WebAssembly pages. current: u32,