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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <store_0_wasm>", "[store_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_10_wasm>", "[store_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_11_wasm>", "[store_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_12_wasm>", "[store_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_13_wasm>", "[store_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_14_wasm>", "[store_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_15_wasm>", "[store_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_16_wasm>", "[store_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_17_wasm>", "[store_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_18_wasm>", "[store_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_19_wasm>", "[store_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_20_wasm>", "[store_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_21_wasm>", "[store_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_22_wasm>", "[store_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_23_wasm>", "[store_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_24_wasm>", "[store_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_25_wasm>", "[store_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_26_wasm>", "[store_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_27_wasm>", "[store_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_28_wasm>", "[store_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_29_wasm>", "[store_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_30_wasm>", "[store_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_31_wasm>", "[store_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_32_wasm>", "[store_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_33_wasm>", "[store_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_34_wasm>", "[store_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_35_wasm>", "[store_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_36_wasm>", "[store_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_37_wasm>", "[store_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_38_wasm>", "[store_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_39_wasm>", "[store_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_40_wasm>", "[store_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_41_wasm>", "[store_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_42_wasm>", "[store_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_43_wasm>", "[store_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_44_wasm>", "[store_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_45_wasm>", "[store_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_46_wasm>", "[store_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_47_wasm>", "[store_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_48_wasm>", "[store_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_49_wasm>", "[store_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_50_wasm>", "[store_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_51_wasm>", "[store_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_52_wasm>", "[store_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_53_wasm>", "[store_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_54_wasm>", "[store_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_55_wasm>", "[store_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_56_wasm>", "[store_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_57_wasm>", "[store_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_58_wasm>", "[store_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_8_wasm>", "[store_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <store_9_wasm>", "[store_9_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/52]

BACKEND_TEST_CASE ( "Testing wasm <store_0_wasm>" ,
"" [store_0_wasm_tests] )

Definition at line 18 of file store_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "store.0.wasm");
21 backend_t bkend( code, &wa );
22
23 CHECK(!bkend.call_with_return("env", "as-block-value"));
24 CHECK(!bkend.call_with_return("env", "as-loop-value"));
25 CHECK(!bkend.call_with_return("env", "as-br-value"));
26 CHECK(!bkend.call_with_return("env", "as-br_if-value"));
27 CHECK(!bkend.call_with_return("env", "as-br_if-value-cond"));
28 CHECK(!bkend.call_with_return("env", "as-br_table-value"));
29 CHECK(!bkend.call_with_return("env", "as-return-value"));
30 CHECK(!bkend.call_with_return("env", "as-if-then"));
31 CHECK(!bkend.call_with_return("env", "as-if-else"));
32}
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)
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
wa
wasm_allocator wa
Definition main.cpp:10
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [2/52]

BACKEND_TEST_CASE ( "Testing wasm <store_10_wasm>" ,
"" [store_10_wasm_tests] )

Definition at line 34 of file store_tests.cpp.

34 {
35 using backend_t = backend<standalone_function_t, TestType>;
36 auto code = read_wasm( std::string(wasm_directory) + "store.10.wasm");
37 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
38}
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/52]

BACKEND_TEST_CASE ( "Testing wasm <store_11_wasm>" ,
"" [store_11_wasm_tests] )

Definition at line 40 of file store_tests.cpp.

40 {
41 using backend_t = backend<standalone_function_t, TestType>;
42 auto code = read_wasm( std::string(wasm_directory) + "store.11.wasm");
43 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
44}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/52]

BACKEND_TEST_CASE ( "Testing wasm <store_12_wasm>" ,
"" [store_12_wasm_tests] )

Definition at line 46 of file store_tests.cpp.

46 {
47 using backend_t = backend<standalone_function_t, TestType>;
48 auto code = read_wasm( std::string(wasm_directory) + "store.12.wasm");
49 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
50}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/52]

BACKEND_TEST_CASE ( "Testing wasm <store_13_wasm>" ,
"" [store_13_wasm_tests] )

Definition at line 52 of file store_tests.cpp.

52 {
53 using backend_t = backend<standalone_function_t, TestType>;
54 auto code = read_wasm( std::string(wasm_directory) + "store.13.wasm");
55 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
56}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/52]

BACKEND_TEST_CASE ( "Testing wasm <store_14_wasm>" ,
"" [store_14_wasm_tests] )

Definition at line 58 of file store_tests.cpp.

58 {
59 using backend_t = backend<standalone_function_t, TestType>;
60 auto code = read_wasm( std::string(wasm_directory) + "store.14.wasm");
61 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
62}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/52]

BACKEND_TEST_CASE ( "Testing wasm <store_15_wasm>" ,
"" [store_15_wasm_tests] )

Definition at line 64 of file store_tests.cpp.

64 {
65 using backend_t = backend<standalone_function_t, TestType>;
66 auto code = read_wasm( std::string(wasm_directory) + "store.15.wasm");
67 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
68}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [8/52]

BACKEND_TEST_CASE ( "Testing wasm <store_16_wasm>" ,
"" [store_16_wasm_tests] )

Definition at line 70 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [9/52]

BACKEND_TEST_CASE ( "Testing wasm <store_17_wasm>" ,
"" [store_17_wasm_tests] )

Definition at line 76 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [10/52]

BACKEND_TEST_CASE ( "Testing wasm <store_18_wasm>" ,
"" [store_18_wasm_tests] )

Definition at line 82 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [11/52]

BACKEND_TEST_CASE ( "Testing wasm <store_19_wasm>" ,
"" [store_19_wasm_tests] )

Definition at line 88 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/52]

BACKEND_TEST_CASE ( "Testing wasm <store_20_wasm>" ,
"" [store_20_wasm_tests] )

Definition at line 94 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [13/52]

BACKEND_TEST_CASE ( "Testing wasm <store_21_wasm>" ,
"" [store_21_wasm_tests] )

Definition at line 100 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [14/52]

BACKEND_TEST_CASE ( "Testing wasm <store_22_wasm>" ,
"" [store_22_wasm_tests] )

Definition at line 106 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/52]

BACKEND_TEST_CASE ( "Testing wasm <store_23_wasm>" ,
"" [store_23_wasm_tests] )

Definition at line 112 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/52]

BACKEND_TEST_CASE ( "Testing wasm <store_24_wasm>" ,
"" [store_24_wasm_tests] )

Definition at line 118 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/52]

BACKEND_TEST_CASE ( "Testing wasm <store_25_wasm>" ,
"" [store_25_wasm_tests] )

Definition at line 124 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/52]

BACKEND_TEST_CASE ( "Testing wasm <store_26_wasm>" ,
"" [store_26_wasm_tests] )

Definition at line 130 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/52]

BACKEND_TEST_CASE ( "Testing wasm <store_27_wasm>" ,
"" [store_27_wasm_tests] )

Definition at line 136 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/52]

BACKEND_TEST_CASE ( "Testing wasm <store_28_wasm>" ,
"" [store_28_wasm_tests] )

Definition at line 142 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/52]

BACKEND_TEST_CASE ( "Testing wasm <store_29_wasm>" ,
"" [store_29_wasm_tests] )

Definition at line 148 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/52]

BACKEND_TEST_CASE ( "Testing wasm <store_30_wasm>" ,
"" [store_30_wasm_tests] )

Definition at line 154 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/52]

BACKEND_TEST_CASE ( "Testing wasm <store_31_wasm>" ,
"" [store_31_wasm_tests] )

Definition at line 160 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [24/52]

BACKEND_TEST_CASE ( "Testing wasm <store_32_wasm>" ,
"" [store_32_wasm_tests] )

Definition at line 166 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/52]

BACKEND_TEST_CASE ( "Testing wasm <store_33_wasm>" ,
"" [store_33_wasm_tests] )

Definition at line 172 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/52]

BACKEND_TEST_CASE ( "Testing wasm <store_34_wasm>" ,
"" [store_34_wasm_tests] )

Definition at line 178 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/52]

BACKEND_TEST_CASE ( "Testing wasm <store_35_wasm>" ,
"" [store_35_wasm_tests] )

Definition at line 184 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/52]

BACKEND_TEST_CASE ( "Testing wasm <store_36_wasm>" ,
"" [store_36_wasm_tests] )

Definition at line 190 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/52]

BACKEND_TEST_CASE ( "Testing wasm <store_37_wasm>" ,
"" [store_37_wasm_tests] )

Definition at line 196 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/52]

BACKEND_TEST_CASE ( "Testing wasm <store_38_wasm>" ,
"" [store_38_wasm_tests] )

Definition at line 202 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/52]

BACKEND_TEST_CASE ( "Testing wasm <store_39_wasm>" ,
"" [store_39_wasm_tests] )

Definition at line 208 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/52]

BACKEND_TEST_CASE ( "Testing wasm <store_40_wasm>" ,
"" [store_40_wasm_tests] )

Definition at line 214 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/52]

BACKEND_TEST_CASE ( "Testing wasm <store_41_wasm>" ,
"" [store_41_wasm_tests] )

Definition at line 220 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/52]

BACKEND_TEST_CASE ( "Testing wasm <store_42_wasm>" ,
"" [store_42_wasm_tests] )

Definition at line 226 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/52]

BACKEND_TEST_CASE ( "Testing wasm <store_43_wasm>" ,
"" [store_43_wasm_tests] )

Definition at line 232 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/52]

BACKEND_TEST_CASE ( "Testing wasm <store_44_wasm>" ,
"" [store_44_wasm_tests] )

Definition at line 238 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/52]

BACKEND_TEST_CASE ( "Testing wasm <store_45_wasm>" ,
"" [store_45_wasm_tests] )

Definition at line 244 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/52]

BACKEND_TEST_CASE ( "Testing wasm <store_46_wasm>" ,
"" [store_46_wasm_tests] )

Definition at line 250 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/52]

BACKEND_TEST_CASE ( "Testing wasm <store_47_wasm>" ,
"" [store_47_wasm_tests] )

Definition at line 256 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/52]

BACKEND_TEST_CASE ( "Testing wasm <store_48_wasm>" ,
"" [store_48_wasm_tests] )

Definition at line 262 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/52]

BACKEND_TEST_CASE ( "Testing wasm <store_49_wasm>" ,
"" [store_49_wasm_tests] )

Definition at line 268 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/52]

BACKEND_TEST_CASE ( "Testing wasm <store_50_wasm>" ,
"" [store_50_wasm_tests] )

Definition at line 274 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/52]

BACKEND_TEST_CASE ( "Testing wasm <store_51_wasm>" ,
"" [store_51_wasm_tests] )

Definition at line 280 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/52]

BACKEND_TEST_CASE ( "Testing wasm <store_52_wasm>" ,
"" [store_52_wasm_tests] )

Definition at line 286 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/52]

BACKEND_TEST_CASE ( "Testing wasm <store_53_wasm>" ,
"" [store_53_wasm_tests] )

Definition at line 292 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/52]

BACKEND_TEST_CASE ( "Testing wasm <store_54_wasm>" ,
"" [store_54_wasm_tests] )

Definition at line 298 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/52]

BACKEND_TEST_CASE ( "Testing wasm <store_55_wasm>" ,
"" [store_55_wasm_tests] )

Definition at line 304 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/52]

BACKEND_TEST_CASE ( "Testing wasm <store_56_wasm>" ,
"" [store_56_wasm_tests] )

Definition at line 310 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/52]

BACKEND_TEST_CASE ( "Testing wasm <store_57_wasm>" ,
"" [store_57_wasm_tests] )

Definition at line 316 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/52]

BACKEND_TEST_CASE ( "Testing wasm <store_58_wasm>" ,
"" [store_58_wasm_tests] )

Definition at line 322 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/52]

BACKEND_TEST_CASE ( "Testing wasm <store_8_wasm>" ,
"" [store_8_wasm_tests] )

Definition at line 328 of file store_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/52]

BACKEND_TEST_CASE ( "Testing wasm <store_9_wasm>" ,
"" [store_9_wasm_tests] )

Definition at line 334 of file store_tests.cpp.

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

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.