Wire Sysio Wire Sysion 1.0.0
Loading...
Searching...
No Matches
Functions | Variables
load_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 load_tests.cpp:

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <load_0_wasm>", "[load_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_14_wasm>", "[load_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_15_wasm>", "[load_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_16_wasm>", "[load_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_17_wasm>", "[load_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_18_wasm>", "[load_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_19_wasm>", "[load_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_20_wasm>", "[load_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_21_wasm>", "[load_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_22_wasm>", "[load_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_23_wasm>", "[load_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_24_wasm>", "[load_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_25_wasm>", "[load_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_26_wasm>", "[load_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_27_wasm>", "[load_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_28_wasm>", "[load_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_29_wasm>", "[load_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_30_wasm>", "[load_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_31_wasm>", "[load_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_32_wasm>", "[load_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_33_wasm>", "[load_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_34_wasm>", "[load_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_35_wasm>", "[load_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_36_wasm>", "[load_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_37_wasm>", "[load_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_38_wasm>", "[load_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_39_wasm>", "[load_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_40_wasm>", "[load_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_41_wasm>", "[load_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_42_wasm>", "[load_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_43_wasm>", "[load_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_44_wasm>", "[load_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_45_wasm>", "[load_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_46_wasm>", "[load_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_47_wasm>", "[load_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_48_wasm>", "[load_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_49_wasm>", "[load_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_50_wasm>", "[load_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_51_wasm>", "[load_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_52_wasm>", "[load_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_53_wasm>", "[load_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_54_wasm>", "[load_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_55_wasm>", "[load_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_56_wasm>", "[load_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_57_wasm>", "[load_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_58_wasm>", "[load_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <load_59_wasm>", "[load_59_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/47]

BACKEND_TEST_CASE ( "Testing wasm <load_0_wasm>" ,
"" [load_0_wasm_tests] )

Definition at line 18 of file load_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "load.0.wasm");
21 backend_t bkend( code, &wa );
22
23 CHECK(bkend.call_with_return("env", "as-br-value")->to_ui32() == UINT32_C(0));
24 CHECK(!bkend.call_with_return("env", "as-br_if-cond"));
25 CHECK(bkend.call_with_return("env", "as-br_if-value")->to_ui32() == UINT32_C(0));
26 CHECK(bkend.call_with_return("env", "as-br_if-value-cond")->to_ui32() == UINT32_C(7));
27 CHECK(!bkend.call_with_return("env", "as-br_table-index"));
28 CHECK(bkend.call_with_return("env", "as-br_table-value")->to_ui32() == UINT32_C(0));
29 CHECK(bkend.call_with_return("env", "as-br_table-value-index")->to_ui32() == UINT32_C(6));
30 CHECK(bkend.call_with_return("env", "as-return-value")->to_ui32() == UINT32_C(0));
31 CHECK(bkend.call_with_return("env", "as-if-cond")->to_ui32() == UINT32_C(1));
32 CHECK(bkend.call_with_return("env", "as-if-then")->to_ui32() == UINT32_C(0));
33 CHECK(bkend.call_with_return("env", "as-if-else")->to_ui32() == UINT32_C(0));
34 CHECK(bkend.call_with_return("env", "as-select-first", UINT32_C(0), UINT32_C(1))->to_ui32() == UINT32_C(0));
35 CHECK(bkend.call_with_return("env", "as-select-second", UINT32_C(0), UINT32_C(0))->to_ui32() == UINT32_C(0));
36 CHECK(bkend.call_with_return("env", "as-select-cond")->to_ui32() == UINT32_C(1));
37 CHECK(bkend.call_with_return("env", "as-call-first")->to_ui32() == UINT32_C(4294967295));
38 CHECK(bkend.call_with_return("env", "as-call-mid")->to_ui32() == UINT32_C(4294967295));
39 CHECK(bkend.call_with_return("env", "as-call-last")->to_ui32() == UINT32_C(4294967295));
40 CHECK(bkend.call_with_return("env", "as-call_indirect-first")->to_ui32() == UINT32_C(4294967295));
41 CHECK(bkend.call_with_return("env", "as-call_indirect-mid")->to_ui32() == UINT32_C(4294967295));
42 CHECK(bkend.call_with_return("env", "as-call_indirect-last")->to_ui32() == UINT32_C(4294967295));
43 CHECK(bkend.call_with_return("env", "as-call_indirect-index")->to_ui32() == UINT32_C(4294967295));
44 CHECK(!bkend.call_with_return("env", "as-local.set-value"));
45 CHECK(bkend.call_with_return("env", "as-local.tee-value")->to_ui32() == UINT32_C(0));
46 CHECK(!bkend.call_with_return("env", "as-global.set-value"));
47 CHECK(bkend.call_with_return("env", "as-load-address")->to_ui32() == UINT32_C(0));
48 CHECK(bkend.call_with_return("env", "as-loadN-address")->to_ui32() == UINT32_C(0));
49 CHECK(!bkend.call_with_return("env", "as-store-address"));
50 CHECK(!bkend.call_with_return("env", "as-store-value"));
51 CHECK(!bkend.call_with_return("env", "as-storeN-address"));
52 CHECK(!bkend.call_with_return("env", "as-storeN-value"));
53 CHECK(bkend.call_with_return("env", "as-unary-operand")->to_ui32() == UINT32_C(32));
54 CHECK(bkend.call_with_return("env", "as-binary-left")->to_ui32() == UINT32_C(10));
55 CHECK(bkend.call_with_return("env", "as-binary-right")->to_ui32() == UINT32_C(10));
56 CHECK(bkend.call_with_return("env", "as-test-operand")->to_ui32() == UINT32_C(1));
57 CHECK(bkend.call_with_return("env", "as-compare-left")->to_ui32() == UINT32_C(1));
58 CHECK(bkend.call_with_return("env", "as-compare-right")->to_ui32() == UINT32_C(1));
59 CHECK(bkend.call_with_return("env", "as-memory.grow-size")->to_ui32() == UINT32_C(1));
60}
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
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/47]

BACKEND_TEST_CASE ( "Testing wasm <load_14_wasm>" ,
"" [load_14_wasm_tests] )

Definition at line 62 of file load_tests.cpp.

62 {
63 using backend_t = backend<standalone_function_t, TestType>;
64 auto code = read_wasm( std::string(wasm_directory) + "load.14.wasm");
65 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
66}
backend_t
sysio::vm::backend< rhf_t > backend_t
Definition hello_driver.cpp:61
CHECK_THROWS_AS
#define CHECK_THROWS_AS(expr, exceptionType)
Definition catch.hpp:203
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/47]

BACKEND_TEST_CASE ( "Testing wasm <load_15_wasm>" ,
"" [load_15_wasm_tests] )

Definition at line 68 of file load_tests.cpp.

68 {
69 using backend_t = backend<standalone_function_t, TestType>;
70 auto code = read_wasm( std::string(wasm_directory) + "load.15.wasm");
71 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
72}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/47]

BACKEND_TEST_CASE ( "Testing wasm <load_16_wasm>" ,
"" [load_16_wasm_tests] )

Definition at line 74 of file load_tests.cpp.

74 {
75 using backend_t = backend<standalone_function_t, TestType>;
76 auto code = read_wasm( std::string(wasm_directory) + "load.16.wasm");
77 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
78}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/47]

BACKEND_TEST_CASE ( "Testing wasm <load_17_wasm>" ,
"" [load_17_wasm_tests] )

Definition at line 80 of file load_tests.cpp.

80 {
81 using backend_t = backend<standalone_function_t, TestType>;
82 auto code = read_wasm( std::string(wasm_directory) + "load.17.wasm");
83 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
84}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/47]

BACKEND_TEST_CASE ( "Testing wasm <load_18_wasm>" ,
"" [load_18_wasm_tests] )

Definition at line 86 of file load_tests.cpp.

86 {
87 using backend_t = backend<standalone_function_t, TestType>;
88 auto code = read_wasm( std::string(wasm_directory) + "load.18.wasm");
89 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
90}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/47]

BACKEND_TEST_CASE ( "Testing wasm <load_19_wasm>" ,
"" [load_19_wasm_tests] )

Definition at line 92 of file load_tests.cpp.

92 {
93 using backend_t = backend<standalone_function_t, TestType>;
94 auto code = read_wasm( std::string(wasm_directory) + "load.19.wasm");
95 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
96}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [8/47]

BACKEND_TEST_CASE ( "Testing wasm <load_20_wasm>" ,
"" [load_20_wasm_tests] )

Definition at line 98 of file load_tests.cpp.

98 {
99 using backend_t = backend<standalone_function_t, TestType>;
100 auto code = read_wasm( std::string(wasm_directory) + "load.20.wasm");
101 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
102}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [9/47]

BACKEND_TEST_CASE ( "Testing wasm <load_21_wasm>" ,
"" [load_21_wasm_tests] )

Definition at line 104 of file load_tests.cpp.

104 {
105 using backend_t = backend<standalone_function_t, TestType>;
106 auto code = read_wasm( std::string(wasm_directory) + "load.21.wasm");
107 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
108}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/47]

BACKEND_TEST_CASE ( "Testing wasm <load_22_wasm>" ,
"" [load_22_wasm_tests] )

Definition at line 110 of file load_tests.cpp.

110 {
111 using backend_t = backend<standalone_function_t, TestType>;
112 auto code = read_wasm( std::string(wasm_directory) + "load.22.wasm");
113 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
114}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [11/47]

BACKEND_TEST_CASE ( "Testing wasm <load_23_wasm>" ,
"" [load_23_wasm_tests] )

Definition at line 116 of file load_tests.cpp.

116 {
117 using backend_t = backend<standalone_function_t, TestType>;
118 auto code = read_wasm( std::string(wasm_directory) + "load.23.wasm");
119 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
120}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [12/47]

BACKEND_TEST_CASE ( "Testing wasm <load_24_wasm>" ,
"" [load_24_wasm_tests] )

Definition at line 122 of file load_tests.cpp.

122 {
123 using backend_t = backend<standalone_function_t, TestType>;
124 auto code = read_wasm( std::string(wasm_directory) + "load.24.wasm");
125 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
126}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/47]

BACKEND_TEST_CASE ( "Testing wasm <load_25_wasm>" ,
"" [load_25_wasm_tests] )

Definition at line 128 of file load_tests.cpp.

128 {
129 using backend_t = backend<standalone_function_t, TestType>;
130 auto code = read_wasm( std::string(wasm_directory) + "load.25.wasm");
131 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
132}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [14/47]

BACKEND_TEST_CASE ( "Testing wasm <load_26_wasm>" ,
"" [load_26_wasm_tests] )

Definition at line 134 of file load_tests.cpp.

134 {
135 using backend_t = backend<standalone_function_t, TestType>;
136 auto code = read_wasm( std::string(wasm_directory) + "load.26.wasm");
137 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
138}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [15/47]

BACKEND_TEST_CASE ( "Testing wasm <load_27_wasm>" ,
"" [load_27_wasm_tests] )

Definition at line 140 of file load_tests.cpp.

140 {
141 using backend_t = backend<standalone_function_t, TestType>;
142 auto code = read_wasm( std::string(wasm_directory) + "load.27.wasm");
143 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
144}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [16/47]

BACKEND_TEST_CASE ( "Testing wasm <load_28_wasm>" ,
"" [load_28_wasm_tests] )

Definition at line 146 of file load_tests.cpp.

146 {
147 using backend_t = backend<standalone_function_t, TestType>;
148 auto code = read_wasm( std::string(wasm_directory) + "load.28.wasm");
149 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
150}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [17/47]

BACKEND_TEST_CASE ( "Testing wasm <load_29_wasm>" ,
"" [load_29_wasm_tests] )

Definition at line 152 of file load_tests.cpp.

152 {
153 using backend_t = backend<standalone_function_t, TestType>;
154 auto code = read_wasm( std::string(wasm_directory) + "load.29.wasm");
155 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
156}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [18/47]

BACKEND_TEST_CASE ( "Testing wasm <load_30_wasm>" ,
"" [load_30_wasm_tests] )

Definition at line 158 of file load_tests.cpp.

158 {
159 using backend_t = backend<standalone_function_t, TestType>;
160 auto code = read_wasm( std::string(wasm_directory) + "load.30.wasm");
161 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
162}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [19/47]

BACKEND_TEST_CASE ( "Testing wasm <load_31_wasm>" ,
"" [load_31_wasm_tests] )

Definition at line 164 of file load_tests.cpp.

164 {
165 using backend_t = backend<standalone_function_t, TestType>;
166 auto code = read_wasm( std::string(wasm_directory) + "load.31.wasm");
167 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
168}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [20/47]

BACKEND_TEST_CASE ( "Testing wasm <load_32_wasm>" ,
"" [load_32_wasm_tests] )

Definition at line 170 of file load_tests.cpp.

170 {
171 using backend_t = backend<standalone_function_t, TestType>;
172 auto code = read_wasm( std::string(wasm_directory) + "load.32.wasm");
173 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
174}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [21/47]

BACKEND_TEST_CASE ( "Testing wasm <load_33_wasm>" ,
"" [load_33_wasm_tests] )

Definition at line 176 of file load_tests.cpp.

176 {
177 using backend_t = backend<standalone_function_t, TestType>;
178 auto code = read_wasm( std::string(wasm_directory) + "load.33.wasm");
179 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
180}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [22/47]

BACKEND_TEST_CASE ( "Testing wasm <load_34_wasm>" ,
"" [load_34_wasm_tests] )

Definition at line 182 of file load_tests.cpp.

182 {
183 using backend_t = backend<standalone_function_t, TestType>;
184 auto code = read_wasm( std::string(wasm_directory) + "load.34.wasm");
185 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
186}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [23/47]

BACKEND_TEST_CASE ( "Testing wasm <load_35_wasm>" ,
"" [load_35_wasm_tests] )

Definition at line 188 of file load_tests.cpp.

188 {
189 using backend_t = backend<standalone_function_t, TestType>;
190 auto code = read_wasm( std::string(wasm_directory) + "load.35.wasm");
191 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
192}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/47]

BACKEND_TEST_CASE ( "Testing wasm <load_36_wasm>" ,
"" [load_36_wasm_tests] )

Definition at line 194 of file load_tests.cpp.

194 {
195 using backend_t = backend<standalone_function_t, TestType>;
196 auto code = read_wasm( std::string(wasm_directory) + "load.36.wasm");
197 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
198}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [25/47]

BACKEND_TEST_CASE ( "Testing wasm <load_37_wasm>" ,
"" [load_37_wasm_tests] )

Definition at line 200 of file load_tests.cpp.

200 {
201 using backend_t = backend<standalone_function_t, TestType>;
202 auto code = read_wasm( std::string(wasm_directory) + "load.37.wasm");
203 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
204}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [26/47]

BACKEND_TEST_CASE ( "Testing wasm <load_38_wasm>" ,
"" [load_38_wasm_tests] )

Definition at line 206 of file load_tests.cpp.

206 {
207 using backend_t = backend<standalone_function_t, TestType>;
208 auto code = read_wasm( std::string(wasm_directory) + "load.38.wasm");
209 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
210}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [27/47]

BACKEND_TEST_CASE ( "Testing wasm <load_39_wasm>" ,
"" [load_39_wasm_tests] )

Definition at line 212 of file load_tests.cpp.

212 {
213 using backend_t = backend<standalone_function_t, TestType>;
214 auto code = read_wasm( std::string(wasm_directory) + "load.39.wasm");
215 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
216}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [28/47]

BACKEND_TEST_CASE ( "Testing wasm <load_40_wasm>" ,
"" [load_40_wasm_tests] )

Definition at line 218 of file load_tests.cpp.

218 {
219 using backend_t = backend<standalone_function_t, TestType>;
220 auto code = read_wasm( std::string(wasm_directory) + "load.40.wasm");
221 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
222}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [29/47]

BACKEND_TEST_CASE ( "Testing wasm <load_41_wasm>" ,
"" [load_41_wasm_tests] )

Definition at line 224 of file load_tests.cpp.

224 {
225 using backend_t = backend<standalone_function_t, TestType>;
226 auto code = read_wasm( std::string(wasm_directory) + "load.41.wasm");
227 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
228}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [30/47]

BACKEND_TEST_CASE ( "Testing wasm <load_42_wasm>" ,
"" [load_42_wasm_tests] )

Definition at line 230 of file load_tests.cpp.

230 {
231 using backend_t = backend<standalone_function_t, TestType>;
232 auto code = read_wasm( std::string(wasm_directory) + "load.42.wasm");
233 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
234}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [31/47]

BACKEND_TEST_CASE ( "Testing wasm <load_43_wasm>" ,
"" [load_43_wasm_tests] )

Definition at line 236 of file load_tests.cpp.

236 {
237 using backend_t = backend<standalone_function_t, TestType>;
238 auto code = read_wasm( std::string(wasm_directory) + "load.43.wasm");
239 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
240}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [32/47]

BACKEND_TEST_CASE ( "Testing wasm <load_44_wasm>" ,
"" [load_44_wasm_tests] )

Definition at line 242 of file load_tests.cpp.

242 {
243 using backend_t = backend<standalone_function_t, TestType>;
244 auto code = read_wasm( std::string(wasm_directory) + "load.44.wasm");
245 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
246}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [33/47]

BACKEND_TEST_CASE ( "Testing wasm <load_45_wasm>" ,
"" [load_45_wasm_tests] )

Definition at line 248 of file load_tests.cpp.

248 {
249 using backend_t = backend<standalone_function_t, TestType>;
250 auto code = read_wasm( std::string(wasm_directory) + "load.45.wasm");
251 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
252}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [34/47]

BACKEND_TEST_CASE ( "Testing wasm <load_46_wasm>" ,
"" [load_46_wasm_tests] )

Definition at line 254 of file load_tests.cpp.

254 {
255 using backend_t = backend<standalone_function_t, TestType>;
256 auto code = read_wasm( std::string(wasm_directory) + "load.46.wasm");
257 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
258}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [35/47]

BACKEND_TEST_CASE ( "Testing wasm <load_47_wasm>" ,
"" [load_47_wasm_tests] )

Definition at line 260 of file load_tests.cpp.

260 {
261 using backend_t = backend<standalone_function_t, TestType>;
262 auto code = read_wasm( std::string(wasm_directory) + "load.47.wasm");
263 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
264}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [36/47]

BACKEND_TEST_CASE ( "Testing wasm <load_48_wasm>" ,
"" [load_48_wasm_tests] )

Definition at line 266 of file load_tests.cpp.

266 {
267 using backend_t = backend<standalone_function_t, TestType>;
268 auto code = read_wasm( std::string(wasm_directory) + "load.48.wasm");
269 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
270}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [37/47]

BACKEND_TEST_CASE ( "Testing wasm <load_49_wasm>" ,
"" [load_49_wasm_tests] )

Definition at line 272 of file load_tests.cpp.

272 {
273 using backend_t = backend<standalone_function_t, TestType>;
274 auto code = read_wasm( std::string(wasm_directory) + "load.49.wasm");
275 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
276}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [38/47]

BACKEND_TEST_CASE ( "Testing wasm <load_50_wasm>" ,
"" [load_50_wasm_tests] )

Definition at line 278 of file load_tests.cpp.

278 {
279 using backend_t = backend<standalone_function_t, TestType>;
280 auto code = read_wasm( std::string(wasm_directory) + "load.50.wasm");
281 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
282}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [39/47]

BACKEND_TEST_CASE ( "Testing wasm <load_51_wasm>" ,
"" [load_51_wasm_tests] )

Definition at line 284 of file load_tests.cpp.

284 {
285 using backend_t = backend<standalone_function_t, TestType>;
286 auto code = read_wasm( std::string(wasm_directory) + "load.51.wasm");
287 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
288}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [40/47]

BACKEND_TEST_CASE ( "Testing wasm <load_52_wasm>" ,
"" [load_52_wasm_tests] )

Definition at line 290 of file load_tests.cpp.

290 {
291 using backend_t = backend<standalone_function_t, TestType>;
292 auto code = read_wasm( std::string(wasm_directory) + "load.52.wasm");
293 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
294}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [41/47]

BACKEND_TEST_CASE ( "Testing wasm <load_53_wasm>" ,
"" [load_53_wasm_tests] )

Definition at line 296 of file load_tests.cpp.

296 {
297 using backend_t = backend<standalone_function_t, TestType>;
298 auto code = read_wasm( std::string(wasm_directory) + "load.53.wasm");
299 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
300}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [42/47]

BACKEND_TEST_CASE ( "Testing wasm <load_54_wasm>" ,
"" [load_54_wasm_tests] )

Definition at line 302 of file load_tests.cpp.

302 {
303 using backend_t = backend<standalone_function_t, TestType>;
304 auto code = read_wasm( std::string(wasm_directory) + "load.54.wasm");
305 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
306}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [43/47]

BACKEND_TEST_CASE ( "Testing wasm <load_55_wasm>" ,
"" [load_55_wasm_tests] )

Definition at line 308 of file load_tests.cpp.

308 {
309 using backend_t = backend<standalone_function_t, TestType>;
310 auto code = read_wasm( std::string(wasm_directory) + "load.55.wasm");
311 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
312}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [44/47]

BACKEND_TEST_CASE ( "Testing wasm <load_56_wasm>" ,
"" [load_56_wasm_tests] )

Definition at line 314 of file load_tests.cpp.

314 {
315 using backend_t = backend<standalone_function_t, TestType>;
316 auto code = read_wasm( std::string(wasm_directory) + "load.56.wasm");
317 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
318}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [45/47]

BACKEND_TEST_CASE ( "Testing wasm <load_57_wasm>" ,
"" [load_57_wasm_tests] )

Definition at line 320 of file load_tests.cpp.

320 {
321 using backend_t = backend<standalone_function_t, TestType>;
322 auto code = read_wasm( std::string(wasm_directory) + "load.57.wasm");
323 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
324}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [46/47]

BACKEND_TEST_CASE ( "Testing wasm <load_58_wasm>" ,
"" [load_58_wasm_tests] )

Definition at line 326 of file load_tests.cpp.

326 {
327 using backend_t = backend<standalone_function_t, TestType>;
328 auto code = read_wasm( std::string(wasm_directory) + "load.58.wasm");
329 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
330}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [47/47]

BACKEND_TEST_CASE ( "Testing wasm <load_59_wasm>" ,
"" [load_59_wasm_tests] )

Definition at line 332 of file load_tests.cpp.

332 {
333 using backend_t = backend<standalone_function_t, TestType>;
334 auto code = read_wasm( std::string(wasm_directory) + "load.59.wasm");
335 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
336}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.