Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Functions | Variables
if_tests.cpp File Reference
#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
#include <cmath>
#include <cstdlib>
#include <catch2/catch.hpp>
#include <utils.hpp>
#include <wasm_config.hpp>
#include <sysio/vm/backend.hpp>
Include dependency graph for if_tests.cpp:

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <if_0_wasm>", "[if_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_1_wasm>", "[if_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_10_wasm>", "[if_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_11_wasm>", "[if_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_12_wasm>", "[if_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_13_wasm>", "[if_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_14_wasm>", "[if_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_15_wasm>", "[if_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_16_wasm>", "[if_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_17_wasm>", "[if_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_18_wasm>", "[if_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_19_wasm>", "[if_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_2_wasm>", "[if_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_20_wasm>", "[if_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_21_wasm>", "[if_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_22_wasm>", "[if_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_23_wasm>", "[if_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_24_wasm>", "[if_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_25_wasm>", "[if_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_26_wasm>", "[if_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_27_wasm>", "[if_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_28_wasm>", "[if_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_29_wasm>", "[if_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_3_wasm>", "[if_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_30_wasm>", "[if_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_31_wasm>", "[if_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_32_wasm>", "[if_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_33_wasm>", "[if_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_34_wasm>", "[if_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_35_wasm>", "[if_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_36_wasm>", "[if_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_37_wasm>", "[if_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_38_wasm>", "[if_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_39_wasm>", "[if_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_4_wasm>", "[if_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_40_wasm>", "[if_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_41_wasm>", "[if_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_42_wasm>", "[if_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_43_wasm>", "[if_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_44_wasm>", "[if_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_45_wasm>", "[if_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_46_wasm>", "[if_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_47_wasm>", "[if_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_48_wasm>", "[if_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_49_wasm>", "[if_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_5_wasm>", "[if_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_50_wasm>", "[if_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_51_wasm>", "[if_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_52_wasm>", "[if_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_6_wasm>", "[if_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_7_wasm>", "[if_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_8_wasm>", "[if_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <if_9_wasm>", "[if_9_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/53]

BACKEND_TEST_CASE ( "Testing wasm <if_0_wasm>" ,
"" [if_0_wasm_tests] )

Definition at line 18 of file if_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "if.0.wasm");
21 backend_t bkend( code, &wa );
22
23 CHECK(!bkend.call_with_return("env", "empty", UINT32_C(0)));
24 CHECK(!bkend.call_with_return("env", "empty", UINT32_C(1)));
25 CHECK(!bkend.call_with_return("env", "empty", UINT32_C(100)));
26 CHECK(!bkend.call_with_return("env", "empty", UINT32_C(4294967294)));
27 CHECK(bkend.call_with_return("env", "singular", UINT32_C(0))->to_ui32() == UINT32_C(8));
28 CHECK(bkend.call_with_return("env", "singular", UINT32_C(1))->to_ui32() == UINT32_C(7));
29 CHECK(bkend.call_with_return("env", "singular", UINT32_C(10))->to_ui32() == UINT32_C(7));
30 CHECK(bkend.call_with_return("env", "singular", UINT32_C(4294967286))->to_ui32() == UINT32_C(7));
31 CHECK(bkend.call_with_return("env", "multi", UINT32_C(0))->to_ui32() == UINT32_C(9));
32 CHECK(bkend.call_with_return("env", "multi", UINT32_C(1))->to_ui32() == UINT32_C(8));
33 CHECK(bkend.call_with_return("env", "multi", UINT32_C(13))->to_ui32() == UINT32_C(8));
34 CHECK(bkend.call_with_return("env", "multi", UINT32_C(4294967291))->to_ui32() == UINT32_C(8));
35 CHECK(bkend.call_with_return("env", "nested", UINT32_C(0), UINT32_C(0))->to_ui32() == UINT32_C(11));
36 CHECK(bkend.call_with_return("env", "nested", UINT32_C(1), UINT32_C(0))->to_ui32() == UINT32_C(10));
37 CHECK(bkend.call_with_return("env", "nested", UINT32_C(0), UINT32_C(1))->to_ui32() == UINT32_C(10));
38 CHECK(bkend.call_with_return("env", "nested", UINT32_C(3), UINT32_C(2))->to_ui32() == UINT32_C(9));
39 CHECK(bkend.call_with_return("env", "nested", UINT32_C(0), UINT32_C(4294967196))->to_ui32() == UINT32_C(10));
40 CHECK(bkend.call_with_return("env", "nested", UINT32_C(10), UINT32_C(10))->to_ui32() == UINT32_C(9));
41 CHECK(bkend.call_with_return("env", "nested", UINT32_C(0), UINT32_C(4294967295))->to_ui32() == UINT32_C(10));
42 CHECK(bkend.call_with_return("env", "nested", UINT32_C(4294967185), UINT32_C(4294967294))->to_ui32() == UINT32_C(9));
43 CHECK(bkend.call_with_return("env", "as-select-first", UINT32_C(0))->to_ui32() == UINT32_C(0));
44 CHECK(bkend.call_with_return("env", "as-select-first", UINT32_C(1))->to_ui32() == UINT32_C(1));
45 CHECK(bkend.call_with_return("env", "as-select-mid", UINT32_C(0))->to_ui32() == UINT32_C(2));
46 CHECK(bkend.call_with_return("env", "as-select-mid", UINT32_C(1))->to_ui32() == UINT32_C(2));
47 CHECK(bkend.call_with_return("env", "as-select-last", UINT32_C(0))->to_ui32() == UINT32_C(3));
48 CHECK(bkend.call_with_return("env", "as-select-last", UINT32_C(1))->to_ui32() == UINT32_C(2));
49 CHECK(bkend.call_with_return("env", "as-loop-first", UINT32_C(0))->to_ui32() == UINT32_C(0));
50 CHECK(bkend.call_with_return("env", "as-loop-first", UINT32_C(1))->to_ui32() == UINT32_C(1));
51 CHECK(bkend.call_with_return("env", "as-loop-mid", UINT32_C(0))->to_ui32() == UINT32_C(0));
52 CHECK(bkend.call_with_return("env", "as-loop-mid", UINT32_C(1))->to_ui32() == UINT32_C(1));
53 CHECK(bkend.call_with_return("env", "as-loop-last", UINT32_C(0))->to_ui32() == UINT32_C(0));
54 CHECK(bkend.call_with_return("env", "as-loop-last", UINT32_C(1))->to_ui32() == UINT32_C(1));
55 CHECK(bkend.call_with_return("env", "as-if-condition", UINT32_C(0))->to_ui32() == UINT32_C(3));
56 CHECK(bkend.call_with_return("env", "as-if-condition", UINT32_C(1))->to_ui32() == UINT32_C(2));
57 CHECK(bkend.call_with_return("env", "as-br_if-first", UINT32_C(0))->to_ui32() == UINT32_C(0));
58 CHECK(bkend.call_with_return("env", "as-br_if-first", UINT32_C(1))->to_ui32() == UINT32_C(1));
59 CHECK(bkend.call_with_return("env", "as-br_if-last", UINT32_C(0))->to_ui32() == UINT32_C(3));
60 CHECK(bkend.call_with_return("env", "as-br_if-last", UINT32_C(1))->to_ui32() == UINT32_C(2));
61 CHECK(bkend.call_with_return("env", "as-br_table-first", UINT32_C(0))->to_ui32() == UINT32_C(0));
62 CHECK(bkend.call_with_return("env", "as-br_table-first", UINT32_C(1))->to_ui32() == UINT32_C(1));
63 CHECK(bkend.call_with_return("env", "as-br_table-last", UINT32_C(0))->to_ui32() == UINT32_C(2));
64 CHECK(bkend.call_with_return("env", "as-br_table-last", UINT32_C(1))->to_ui32() == UINT32_C(2));
65 CHECK(bkend.call_with_return("env", "as-call_indirect-first", UINT32_C(0))->to_ui32() == UINT32_C(0));
66 CHECK(bkend.call_with_return("env", "as-call_indirect-first", UINT32_C(1))->to_ui32() == UINT32_C(1));
67 CHECK(bkend.call_with_return("env", "as-call_indirect-mid", UINT32_C(0))->to_ui32() == UINT32_C(2));
68 CHECK(bkend.call_with_return("env", "as-call_indirect-mid", UINT32_C(1))->to_ui32() == UINT32_C(2));
69 CHECK(bkend.call_with_return("env", "as-call_indirect-last", UINT32_C(0))->to_ui32() == UINT32_C(2));
70 CHECK_THROWS_AS(bkend("env", "as-call_indirect-last", UINT32_C(1)), std::exception);
71 CHECK(!bkend.call_with_return("env", "as-store-first", UINT32_C(0)));
72 CHECK(!bkend.call_with_return("env", "as-store-first", UINT32_C(1)));
73 CHECK(!bkend.call_with_return("env", "as-store-last", UINT32_C(0)));
74 CHECK(!bkend.call_with_return("env", "as-store-last", UINT32_C(1)));
75 CHECK(bkend.call_with_return("env", "as-memory.grow-value", UINT32_C(0))->to_ui32() == UINT32_C(1));
76 CHECK(bkend.call_with_return("env", "as-memory.grow-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
77 CHECK(bkend.call_with_return("env", "as-call-value", UINT32_C(0))->to_ui32() == UINT32_C(0));
78 CHECK(bkend.call_with_return("env", "as-call-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
79 CHECK(bkend.call_with_return("env", "as-return-value", UINT32_C(0))->to_ui32() == UINT32_C(0));
80 CHECK(bkend.call_with_return("env", "as-return-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
81 CHECK(!bkend.call_with_return("env", "as-drop-operand", UINT32_C(0)));
82 CHECK(!bkend.call_with_return("env", "as-drop-operand", UINT32_C(1)));
83 CHECK(bkend.call_with_return("env", "as-br-value", UINT32_C(0))->to_ui32() == UINT32_C(0));
84 CHECK(bkend.call_with_return("env", "as-br-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
85 CHECK(bkend.call_with_return("env", "as-local.set-value", UINT32_C(0))->to_ui32() == UINT32_C(0));
86 CHECK(bkend.call_with_return("env", "as-local.set-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
87 CHECK(bkend.call_with_return("env", "as-local.tee-value", UINT32_C(0))->to_ui32() == UINT32_C(0));
88 CHECK(bkend.call_with_return("env", "as-local.tee-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
89 CHECK(bkend.call_with_return("env", "as-global.set-value", UINT32_C(0))->to_ui32() == UINT32_C(0));
90 CHECK(bkend.call_with_return("env", "as-global.set-value", UINT32_C(1))->to_ui32() == UINT32_C(1));
91 CHECK(bkend.call_with_return("env", "as-load-operand", UINT32_C(0))->to_ui32() == UINT32_C(0));
92 CHECK(bkend.call_with_return("env", "as-load-operand", UINT32_C(1))->to_ui32() == UINT32_C(0));
93 CHECK(bkend.call_with_return("env", "as-unary-operand", UINT32_C(0))->to_ui32() == UINT32_C(0));
94 CHECK(bkend.call_with_return("env", "as-unary-operand", UINT32_C(1))->to_ui32() == UINT32_C(0));
95 CHECK(bkend.call_with_return("env", "as-unary-operand", UINT32_C(4294967295))->to_ui32() == UINT32_C(0));
96 CHECK(bkend.call_with_return("env", "as-binary-operand", UINT32_C(0), UINT32_C(0))->to_ui32() == UINT32_C(15));
97 CHECK(bkend.call_with_return("env", "as-binary-operand", UINT32_C(0), UINT32_C(1))->to_ui32() == UINT32_C(4294967284));
98 CHECK(bkend.call_with_return("env", "as-binary-operand", UINT32_C(1), UINT32_C(0))->to_ui32() == UINT32_C(4294967281));
99 CHECK(bkend.call_with_return("env", "as-binary-operand", UINT32_C(1), UINT32_C(1))->to_ui32() == UINT32_C(12));
100 CHECK(bkend.call_with_return("env", "as-test-operand", UINT32_C(0))->to_ui32() == UINT32_C(1));
101 CHECK(bkend.call_with_return("env", "as-test-operand", UINT32_C(1))->to_ui32() == UINT32_C(0));
102 CHECK(bkend.call_with_return("env", "as-compare-operand", UINT32_C(0), UINT32_C(0))->to_ui32() == UINT32_C(1));
103 CHECK(bkend.call_with_return("env", "as-compare-operand", UINT32_C(0), UINT32_C(1))->to_ui32() == UINT32_C(0));
104 CHECK(bkend.call_with_return("env", "as-compare-operand", UINT32_C(1), UINT32_C(0))->to_ui32() == UINT32_C(1));
105 CHECK(bkend.call_with_return("env", "as-compare-operand", UINT32_C(1), UINT32_C(1))->to_ui32() == UINT32_C(0));
106 CHECK(bkend.call_with_return("env", "break-bare")->to_ui32() == UINT32_C(19));
107 CHECK(bkend.call_with_return("env", "break-value", UINT32_C(1))->to_ui32() == UINT32_C(18));
108 CHECK(bkend.call_with_return("env", "break-value", UINT32_C(0))->to_ui32() == UINT32_C(21));
109 CHECK(bkend.call_with_return("env", "effects", UINT32_C(1))->to_ui32() == UINT32_C(4294967282));
110 CHECK(bkend.call_with_return("env", "effects", UINT32_C(0))->to_ui32() == UINT32_C(4294967290));
111}
sysio::vm::backend::call_with_return
auto call_with_return(host_t &host, const std::string_view &mod, const std::string_view &func, Args... args)
Definition backend.hpp:178
CHECK
#define CHECK(cond)
Definition util.h:80
bkend
backend_t bkend(hello_wasm, ehm, &wa)
wa
wasm_allocator wa
Definition main.cpp:10
CHECK_THROWS_AS
#define CHECK_THROWS_AS(expr, exceptionType)
Definition catch.hpp:203
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
UINT32_C
#define UINT32_C(val)
Definition stdint.h:283
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [2/53]

BACKEND_TEST_CASE ( "Testing wasm <if_10_wasm>" ,
"" [if_10_wasm_tests] )

Definition at line 119 of file if_tests.cpp.

119 {
120 using backend_t = backend<standalone_function_t, TestType>;
121 auto code = read_wasm( std::string(wasm_directory) + "if.10.wasm");
122 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
123}
backend_t
sysio::vm::backend< rhf_t > backend_t
Definition hello_driver.cpp:61
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/53]

BACKEND_TEST_CASE ( "Testing wasm <if_11_wasm>" ,
"" [if_11_wasm_tests] )

Definition at line 125 of file if_tests.cpp.

125 {
126 using backend_t = backend<standalone_function_t, TestType>;
127 auto code = read_wasm( std::string(wasm_directory) + "if.11.wasm");
128 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
129}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/53]

BACKEND_TEST_CASE ( "Testing wasm <if_12_wasm>" ,
"" [if_12_wasm_tests] )

Definition at line 131 of file if_tests.cpp.

131 {
132 using backend_t = backend<standalone_function_t, TestType>;
133 auto code = read_wasm( std::string(wasm_directory) + "if.12.wasm");
134 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
135}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/53]

BACKEND_TEST_CASE ( "Testing wasm <if_13_wasm>" ,
"" [if_13_wasm_tests] )

Definition at line 137 of file if_tests.cpp.

137 {
138 using backend_t = backend<standalone_function_t, TestType>;
139 auto code = read_wasm( std::string(wasm_directory) + "if.13.wasm");
140 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
141}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/53]

BACKEND_TEST_CASE ( "Testing wasm <if_14_wasm>" ,
"" [if_14_wasm_tests] )

Definition at line 143 of file if_tests.cpp.

143 {
144 using backend_t = backend<standalone_function_t, TestType>;
145 auto code = read_wasm( std::string(wasm_directory) + "if.14.wasm");
146 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
147}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/53]

BACKEND_TEST_CASE ( "Testing wasm <if_15_wasm>" ,
"" [if_15_wasm_tests] )

Definition at line 149 of file if_tests.cpp.

149 {
150 using backend_t = backend<standalone_function_t, TestType>;
151 auto code = read_wasm( std::string(wasm_directory) + "if.15.wasm");
152 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
153}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [8/53]

BACKEND_TEST_CASE ( "Testing wasm <if_16_wasm>" ,
"" [if_16_wasm_tests] )

Definition at line 155 of file if_tests.cpp.

155 {
156 using backend_t = backend<standalone_function_t, TestType>;
157 auto code = read_wasm( std::string(wasm_directory) + "if.16.wasm");
158 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
159}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [9/53]

BACKEND_TEST_CASE ( "Testing wasm <if_17_wasm>" ,
"" [if_17_wasm_tests] )

Definition at line 161 of file if_tests.cpp.

161 {
162 using backend_t = backend<standalone_function_t, TestType>;
163 auto code = read_wasm( std::string(wasm_directory) + "if.17.wasm");
164 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
165}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/53]

BACKEND_TEST_CASE ( "Testing wasm <if_18_wasm>" ,
"" [if_18_wasm_tests] )

Definition at line 167 of file if_tests.cpp.

167 {
168 using backend_t = backend<standalone_function_t, TestType>;
169 auto code = read_wasm( std::string(wasm_directory) + "if.18.wasm");
170 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
171}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [11/53]

BACKEND_TEST_CASE ( "Testing wasm <if_19_wasm>" ,
"" [if_19_wasm_tests] )

Definition at line 173 of file if_tests.cpp.

173 {
174 using backend_t = backend<standalone_function_t, TestType>;
175 auto code = read_wasm( std::string(wasm_directory) + "if.19.wasm");
176 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
177}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [12/53]

BACKEND_TEST_CASE ( "Testing wasm <if_1_wasm>" ,
"" [if_1_wasm_tests] )

Definition at line 113 of file if_tests.cpp.

113 {
114 using backend_t = backend<standalone_function_t, TestType>;
115 auto code = read_wasm( std::string(wasm_directory) + "if.1.wasm");
116 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
117}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/53]

BACKEND_TEST_CASE ( "Testing wasm <if_20_wasm>" ,
"" [if_20_wasm_tests] )

Definition at line 185 of file if_tests.cpp.

185 {
186 using backend_t = backend<standalone_function_t, TestType>;
187 auto code = read_wasm( std::string(wasm_directory) + "if.20.wasm");
188 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
189}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [14/53]

BACKEND_TEST_CASE ( "Testing wasm <if_21_wasm>" ,
"" [if_21_wasm_tests] )

Definition at line 191 of file if_tests.cpp.

191 {
192 using backend_t = backend<standalone_function_t, TestType>;
193 auto code = read_wasm( std::string(wasm_directory) + "if.21.wasm");
194 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
195}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [15/53]

BACKEND_TEST_CASE ( "Testing wasm <if_22_wasm>" ,
"" [if_22_wasm_tests] )

Definition at line 197 of file if_tests.cpp.

197 {
198 using backend_t = backend<standalone_function_t, TestType>;
199 auto code = read_wasm( std::string(wasm_directory) + "if.22.wasm");
200 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
201}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [16/53]

BACKEND_TEST_CASE ( "Testing wasm <if_23_wasm>" ,
"" [if_23_wasm_tests] )

Definition at line 203 of file if_tests.cpp.

203 {
204 using backend_t = backend<standalone_function_t, TestType>;
205 auto code = read_wasm( std::string(wasm_directory) + "if.23.wasm");
206 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
207}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [17/53]

BACKEND_TEST_CASE ( "Testing wasm <if_24_wasm>" ,
"" [if_24_wasm_tests] )

Definition at line 209 of file if_tests.cpp.

209 {
210 using backend_t = backend<standalone_function_t, TestType>;
211 auto code = read_wasm( std::string(wasm_directory) + "if.24.wasm");
212 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
213}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [18/53]

BACKEND_TEST_CASE ( "Testing wasm <if_25_wasm>" ,
"" [if_25_wasm_tests] )

Definition at line 215 of file if_tests.cpp.

215 {
216 using backend_t = backend<standalone_function_t, TestType>;
217 auto code = read_wasm( std::string(wasm_directory) + "if.25.wasm");
218 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
219}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [19/53]

BACKEND_TEST_CASE ( "Testing wasm <if_26_wasm>" ,
"" [if_26_wasm_tests] )

Definition at line 221 of file if_tests.cpp.

221 {
222 using backend_t = backend<standalone_function_t, TestType>;
223 auto code = read_wasm( std::string(wasm_directory) + "if.26.wasm");
224 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
225}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [20/53]

BACKEND_TEST_CASE ( "Testing wasm <if_27_wasm>" ,
"" [if_27_wasm_tests] )

Definition at line 227 of file if_tests.cpp.

227 {
228 using backend_t = backend<standalone_function_t, TestType>;
229 auto code = read_wasm( std::string(wasm_directory) + "if.27.wasm");
230 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
231}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [21/53]

BACKEND_TEST_CASE ( "Testing wasm <if_28_wasm>" ,
"" [if_28_wasm_tests] )

Definition at line 233 of file if_tests.cpp.

233 {
234 using backend_t = backend<standalone_function_t, TestType>;
235 auto code = read_wasm( std::string(wasm_directory) + "if.28.wasm");
236 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
237}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [22/53]

BACKEND_TEST_CASE ( "Testing wasm <if_29_wasm>" ,
"" [if_29_wasm_tests] )

Definition at line 239 of file if_tests.cpp.

239 {
240 using backend_t = backend<standalone_function_t, TestType>;
241 auto code = read_wasm( std::string(wasm_directory) + "if.29.wasm");
242 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
243}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [23/53]

BACKEND_TEST_CASE ( "Testing wasm <if_2_wasm>" ,
"" [if_2_wasm_tests] )

Definition at line 179 of file if_tests.cpp.

179 {
180 using backend_t = backend<standalone_function_t, TestType>;
181 auto code = read_wasm( std::string(wasm_directory) + "if.2.wasm");
182 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
183}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/53]

BACKEND_TEST_CASE ( "Testing wasm <if_30_wasm>" ,
"" [if_30_wasm_tests] )

Definition at line 251 of file if_tests.cpp.

251 {
252 using backend_t = backend<standalone_function_t, TestType>;
253 auto code = read_wasm( std::string(wasm_directory) + "if.30.wasm");
254 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
255}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [25/53]

BACKEND_TEST_CASE ( "Testing wasm <if_31_wasm>" ,
"" [if_31_wasm_tests] )

Definition at line 257 of file if_tests.cpp.

257 {
258 using backend_t = backend<standalone_function_t, TestType>;
259 auto code = read_wasm( std::string(wasm_directory) + "if.31.wasm");
260 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
261}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [26/53]

BACKEND_TEST_CASE ( "Testing wasm <if_32_wasm>" ,
"" [if_32_wasm_tests] )

Definition at line 263 of file if_tests.cpp.

263 {
264 using backend_t = backend<standalone_function_t, TestType>;
265 auto code = read_wasm( std::string(wasm_directory) + "if.32.wasm");
266 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
267}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [27/53]

BACKEND_TEST_CASE ( "Testing wasm <if_33_wasm>" ,
"" [if_33_wasm_tests] )

Definition at line 269 of file if_tests.cpp.

269 {
270 using backend_t = backend<standalone_function_t, TestType>;
271 auto code = read_wasm( std::string(wasm_directory) + "if.33.wasm");
272 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
273}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [28/53]

BACKEND_TEST_CASE ( "Testing wasm <if_34_wasm>" ,
"" [if_34_wasm_tests] )

Definition at line 275 of file if_tests.cpp.

275 {
276 using backend_t = backend<standalone_function_t, TestType>;
277 auto code = read_wasm( std::string(wasm_directory) + "if.34.wasm");
278 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
279}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [29/53]

BACKEND_TEST_CASE ( "Testing wasm <if_35_wasm>" ,
"" [if_35_wasm_tests] )

Definition at line 281 of file if_tests.cpp.

281 {
282 using backend_t = backend<standalone_function_t, TestType>;
283 auto code = read_wasm( std::string(wasm_directory) + "if.35.wasm");
284 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
285}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [30/53]

BACKEND_TEST_CASE ( "Testing wasm <if_36_wasm>" ,
"" [if_36_wasm_tests] )

Definition at line 287 of file if_tests.cpp.

287 {
288 using backend_t = backend<standalone_function_t, TestType>;
289 auto code = read_wasm( std::string(wasm_directory) + "if.36.wasm");
290 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
291}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [31/53]

BACKEND_TEST_CASE ( "Testing wasm <if_37_wasm>" ,
"" [if_37_wasm_tests] )

Definition at line 293 of file if_tests.cpp.

293 {
294 using backend_t = backend<standalone_function_t, TestType>;
295 auto code = read_wasm( std::string(wasm_directory) + "if.37.wasm");
296 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
297}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [32/53]

BACKEND_TEST_CASE ( "Testing wasm <if_38_wasm>" ,
"" [if_38_wasm_tests] )

Definition at line 299 of file if_tests.cpp.

299 {
300 using backend_t = backend<standalone_function_t, TestType>;
301 auto code = read_wasm( std::string(wasm_directory) + "if.38.wasm");
302 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
303}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [33/53]

BACKEND_TEST_CASE ( "Testing wasm <if_39_wasm>" ,
"" [if_39_wasm_tests] )

Definition at line 305 of file if_tests.cpp.

305 {
306 using backend_t = backend<standalone_function_t, TestType>;
307 auto code = read_wasm( std::string(wasm_directory) + "if.39.wasm");
308 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
309}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [34/53]

BACKEND_TEST_CASE ( "Testing wasm <if_3_wasm>" ,
"" [if_3_wasm_tests] )

Definition at line 245 of file if_tests.cpp.

245 {
246 using backend_t = backend<standalone_function_t, TestType>;
247 auto code = read_wasm( std::string(wasm_directory) + "if.3.wasm");
248 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
249}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [35/53]

BACKEND_TEST_CASE ( "Testing wasm <if_40_wasm>" ,
"" [if_40_wasm_tests] )

Definition at line 317 of file if_tests.cpp.

317 {
318 using backend_t = backend<standalone_function_t, TestType>;
319 auto code = read_wasm( std::string(wasm_directory) + "if.40.wasm");
320 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
321}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [36/53]

BACKEND_TEST_CASE ( "Testing wasm <if_41_wasm>" ,
"" [if_41_wasm_tests] )

Definition at line 323 of file if_tests.cpp.

323 {
324 using backend_t = backend<standalone_function_t, TestType>;
325 auto code = read_wasm( std::string(wasm_directory) + "if.41.wasm");
326 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
327}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [37/53]

BACKEND_TEST_CASE ( "Testing wasm <if_42_wasm>" ,
"" [if_42_wasm_tests] )

Definition at line 329 of file if_tests.cpp.

329 {
330 using backend_t = backend<standalone_function_t, TestType>;
331 auto code = read_wasm( std::string(wasm_directory) + "if.42.wasm");
332 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
333}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [38/53]

BACKEND_TEST_CASE ( "Testing wasm <if_43_wasm>" ,
"" [if_43_wasm_tests] )

Definition at line 335 of file if_tests.cpp.

335 {
336 using backend_t = backend<standalone_function_t, TestType>;
337 auto code = read_wasm( std::string(wasm_directory) + "if.43.wasm");
338 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
339}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [39/53]

BACKEND_TEST_CASE ( "Testing wasm <if_44_wasm>" ,
"" [if_44_wasm_tests] )

Definition at line 341 of file if_tests.cpp.

341 {
342 using backend_t = backend<standalone_function_t, TestType>;
343 auto code = read_wasm( std::string(wasm_directory) + "if.44.wasm");
344 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
345}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [40/53]

BACKEND_TEST_CASE ( "Testing wasm <if_45_wasm>" ,
"" [if_45_wasm_tests] )

Definition at line 347 of file if_tests.cpp.

347 {
348 using backend_t = backend<standalone_function_t, TestType>;
349 auto code = read_wasm( std::string(wasm_directory) + "if.45.wasm");
350 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
351}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [41/53]

BACKEND_TEST_CASE ( "Testing wasm <if_46_wasm>" ,
"" [if_46_wasm_tests] )

Definition at line 353 of file if_tests.cpp.

353 {
354 using backend_t = backend<standalone_function_t, TestType>;
355 auto code = read_wasm( std::string(wasm_directory) + "if.46.wasm");
356 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
357}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [42/53]

BACKEND_TEST_CASE ( "Testing wasm <if_47_wasm>" ,
"" [if_47_wasm_tests] )

Definition at line 359 of file if_tests.cpp.

359 {
360 using backend_t = backend<standalone_function_t, TestType>;
361 auto code = read_wasm( std::string(wasm_directory) + "if.47.wasm");
362 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
363}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [43/53]

BACKEND_TEST_CASE ( "Testing wasm <if_48_wasm>" ,
"" [if_48_wasm_tests] )

Definition at line 365 of file if_tests.cpp.

365 {
366 using backend_t = backend<standalone_function_t, TestType>;
367 auto code = read_wasm( std::string(wasm_directory) + "if.48.wasm");
368 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
369}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [44/53]

BACKEND_TEST_CASE ( "Testing wasm <if_49_wasm>" ,
"" [if_49_wasm_tests] )

Definition at line 371 of file if_tests.cpp.

371 {
372 using backend_t = backend<standalone_function_t, TestType>;
373 auto code = read_wasm( std::string(wasm_directory) + "if.49.wasm");
374 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
375}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [45/53]

BACKEND_TEST_CASE ( "Testing wasm <if_4_wasm>" ,
"" [if_4_wasm_tests] )

Definition at line 311 of file if_tests.cpp.

311 {
312 using backend_t = backend<standalone_function_t, TestType>;
313 auto code = read_wasm( std::string(wasm_directory) + "if.4.wasm");
314 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
315}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [46/53]

BACKEND_TEST_CASE ( "Testing wasm <if_50_wasm>" ,
"" [if_50_wasm_tests] )

Definition at line 383 of file if_tests.cpp.

383 {
384 using backend_t = backend<standalone_function_t, TestType>;
385 auto code = read_wasm( std::string(wasm_directory) + "if.50.wasm");
386 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
387}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [47/53]

BACKEND_TEST_CASE ( "Testing wasm <if_51_wasm>" ,
"" [if_51_wasm_tests] )

Definition at line 389 of file if_tests.cpp.

389 {
390 using backend_t = backend<standalone_function_t, TestType>;
391 auto code = read_wasm( std::string(wasm_directory) + "if.51.wasm");
392 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
393}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [48/53]

BACKEND_TEST_CASE ( "Testing wasm <if_52_wasm>" ,
"" [if_52_wasm_tests] )

Definition at line 395 of file if_tests.cpp.

395 {
396 using backend_t = backend<standalone_function_t, TestType>;
397 auto code = read_wasm( std::string(wasm_directory) + "if.52.wasm");
398 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
399}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [49/53]

BACKEND_TEST_CASE ( "Testing wasm <if_5_wasm>" ,
"" [if_5_wasm_tests] )

Definition at line 377 of file if_tests.cpp.

377 {
378 using backend_t = backend<standalone_function_t, TestType>;
379 auto code = read_wasm( std::string(wasm_directory) + "if.5.wasm");
380 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
381}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [50/53]

BACKEND_TEST_CASE ( "Testing wasm <if_6_wasm>" ,
"" [if_6_wasm_tests] )

Definition at line 401 of file if_tests.cpp.

401 {
402 using backend_t = backend<standalone_function_t, TestType>;
403 auto code = read_wasm( std::string(wasm_directory) + "if.6.wasm");
404 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
405}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [51/53]

BACKEND_TEST_CASE ( "Testing wasm <if_7_wasm>" ,
"" [if_7_wasm_tests] )

Definition at line 407 of file if_tests.cpp.

407 {
408 using backend_t = backend<standalone_function_t, TestType>;
409 auto code = read_wasm( std::string(wasm_directory) + "if.7.wasm");
410 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
411}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [52/53]

BACKEND_TEST_CASE ( "Testing wasm <if_8_wasm>" ,
"" [if_8_wasm_tests] )

Definition at line 413 of file if_tests.cpp.

413 {
414 using backend_t = backend<standalone_function_t, TestType>;
415 auto code = read_wasm( std::string(wasm_directory) + "if.8.wasm");
416 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
417}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [53/53]

BACKEND_TEST_CASE ( "Testing wasm <if_9_wasm>" ,
"" [if_9_wasm_tests] )

Definition at line 419 of file if_tests.cpp.

419 {
420 using backend_t = backend<standalone_function_t, TestType>;
421 auto code = read_wasm( std::string(wasm_directory) + "if.9.wasm");
422 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
423}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.