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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <binary_0_wasm>", "[binary_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_1_wasm>", "[binary_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_10_wasm>", "[binary_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_11_wasm>", "[binary_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_12_wasm>", "[binary_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_13_wasm>", "[binary_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_14_wasm>", "[binary_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_15_wasm>", "[binary_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_16_wasm>", "[binary_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_17_wasm>", "[binary_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_18_wasm>", "[binary_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_19_wasm>", "[binary_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_2_wasm>", "[binary_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_20_wasm>", "[binary_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_21_wasm>", "[binary_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_22_wasm>", "[binary_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_23_wasm>", "[binary_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_24_wasm>", "[binary_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_25_wasm>", "[binary_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_26_wasm>", "[binary_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_27_wasm>", "[binary_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_28_wasm>", "[binary_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_29_wasm>", "[binary_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_3_wasm>", "[binary_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_30_wasm>", "[binary_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_31_wasm>", "[binary_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_32_wasm>", "[binary_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_33_wasm>", "[binary_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_34_wasm>", "[binary_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_35_wasm>", "[binary_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_36_wasm>", "[binary_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_37_wasm>", "[binary_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_38_wasm>", "[binary_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_39_wasm>", "[binary_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_4_wasm>", "[binary_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_40_wasm>", "[binary_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_41_wasm>", "[binary_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_42_wasm>", "[binary_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_43_wasm>", "[binary_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_44_wasm>", "[binary_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_45_wasm>", "[binary_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_46_wasm>", "[binary_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_47_wasm>", "[binary_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_48_wasm>", "[binary_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_49_wasm>", "[binary_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_5_wasm>", "[binary_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_50_wasm>", "[binary_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_51_wasm>", "[binary_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_52_wasm>", "[binary_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_53_wasm>", "[binary_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_54_wasm>", "[binary_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_6_wasm>", "[binary_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_7_wasm>", "[binary_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_8_wasm>", "[binary_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary_9_wasm>", "[binary_9_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_0_wasm>" ,
"" [binary_0_wasm_tests] )

Definition at line 18 of file binary_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "binary.0.wasm");
21 backend_t bkend( code, &wa );
22
23}
wa
wasm_allocator wa
Definition main.cpp:10
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
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [2/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_10_wasm>" ,
"" [binary_10_wasm_tests] )

Definition at line 32 of file binary_tests.cpp.

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

BACKEND_TEST_CASE ( "Testing wasm <binary_11_wasm>" ,
"" [binary_11_wasm_tests] )

Definition at line 38 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [4/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_12_wasm>" ,
"" [binary_12_wasm_tests] )

Definition at line 44 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [5/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_13_wasm>" ,
"" [binary_13_wasm_tests] )

Definition at line 50 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [6/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_14_wasm>" ,
"" [binary_14_wasm_tests] )

Definition at line 56 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [7/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_15_wasm>" ,
"" [binary_15_wasm_tests] )

Definition at line 62 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [8/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_16_wasm>" ,
"" [binary_16_wasm_tests] )

Definition at line 68 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [9/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_17_wasm>" ,
"" [binary_17_wasm_tests] )

Definition at line 74 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [10/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_18_wasm>" ,
"" [binary_18_wasm_tests] )

Definition at line 80 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [11/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_19_wasm>" ,
"" [binary_19_wasm_tests] )

Definition at line 86 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_1_wasm>" ,
"" [binary_1_wasm_tests] )

Definition at line 25 of file binary_tests.cpp.

25 {
26 using backend_t = backend<standalone_function_t, TestType>;
27 auto code = read_wasm( std::string(wasm_directory) + "binary.1.wasm");
28 backend_t bkend( code, &wa );
29
30}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_20_wasm>" ,
"" [binary_20_wasm_tests] )

Definition at line 99 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [14/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_21_wasm>" ,
"" [binary_21_wasm_tests] )

Definition at line 105 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_22_wasm>" ,
"" [binary_22_wasm_tests] )

Definition at line 111 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_23_wasm>" ,
"" [binary_23_wasm_tests] )

Definition at line 117 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_24_wasm>" ,
"" [binary_24_wasm_tests] )

Definition at line 123 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_25_wasm>" ,
"" [binary_25_wasm_tests] )

Definition at line 129 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_26_wasm>" ,
"" [binary_26_wasm_tests] )

Definition at line 135 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_27_wasm>" ,
"" [binary_27_wasm_tests] )

Definition at line 141 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_28_wasm>" ,
"" [binary_28_wasm_tests] )

Definition at line 147 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_29_wasm>" ,
"" [binary_29_wasm_tests] )

Definition at line 153 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_2_wasm>" ,
"" [binary_2_wasm_tests] )

Definition at line 92 of file binary_tests.cpp.

92 {
93 using backend_t = backend<standalone_function_t, TestType>;
94 auto code = read_wasm( std::string(wasm_directory) + "binary.2.wasm");
95 backend_t bkend( code, &wa );
96
97}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_30_wasm>" ,
"" [binary_30_wasm_tests] )

Definition at line 166 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_31_wasm>" ,
"" [binary_31_wasm_tests] )

Definition at line 172 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_32_wasm>" ,
"" [binary_32_wasm_tests] )

Definition at line 178 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_33_wasm>" ,
"" [binary_33_wasm_tests] )

Definition at line 184 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_34_wasm>" ,
"" [binary_34_wasm_tests] )

Definition at line 190 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_35_wasm>" ,
"" [binary_35_wasm_tests] )

Definition at line 196 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_36_wasm>" ,
"" [binary_36_wasm_tests] )

Definition at line 202 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_37_wasm>" ,
"" [binary_37_wasm_tests] )

Definition at line 208 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_38_wasm>" ,
"" [binary_38_wasm_tests] )

Definition at line 214 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_39_wasm>" ,
"" [binary_39_wasm_tests] )

Definition at line 220 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_3_wasm>" ,
"" [binary_3_wasm_tests] )

Definition at line 159 of file binary_tests.cpp.

159 {
160 using backend_t = backend<standalone_function_t, TestType>;
161 auto code = read_wasm( std::string(wasm_directory) + "binary.3.wasm");
162 backend_t bkend( code, &wa );
163
164}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [35/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_40_wasm>" ,
"" [binary_40_wasm_tests] )

Definition at line 232 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_41_wasm>" ,
"" [binary_41_wasm_tests] )

Definition at line 238 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_42_wasm>" ,
"" [binary_42_wasm_tests] )

Definition at line 244 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_43_wasm>" ,
"" [binary_43_wasm_tests] )

Definition at line 250 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_44_wasm>" ,
"" [binary_44_wasm_tests] )

Definition at line 256 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_45_wasm>" ,
"" [binary_45_wasm_tests] )

Definition at line 262 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_46_wasm>" ,
"" [binary_46_wasm_tests] )

Definition at line 268 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_47_wasm>" ,
"" [binary_47_wasm_tests] )

Definition at line 274 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_48_wasm>" ,
"" [binary_48_wasm_tests] )

Definition at line 280 of file binary_tests.cpp.

280 {
281 using backend_t = backend<standalone_function_t, TestType>;
282 auto code = read_wasm( std::string(wasm_directory) + "binary.48.wasm");
283 backend_t bkend( code, &wa );
284
285}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [44/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_49_wasm>" ,
"" [binary_49_wasm_tests] )

Definition at line 287 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_4_wasm>" ,
"" [binary_4_wasm_tests] )

Definition at line 226 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_50_wasm>" ,
"" [binary_50_wasm_tests] )

Definition at line 299 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_51_wasm>" ,
"" [binary_51_wasm_tests] )

Definition at line 305 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_52_wasm>" ,
"" [binary_52_wasm_tests] )

Definition at line 311 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_53_wasm>" ,
"" [binary_53_wasm_tests] )

Definition at line 317 of file binary_tests.cpp.

317 {
318 using backend_t = backend<standalone_function_t, TestType>;
319 auto code = read_wasm( std::string(wasm_directory) + "binary.53.wasm");
320 backend_t bkend( code, &wa );
321
322}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [50/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_54_wasm>" ,
"" [binary_54_wasm_tests] )

Definition at line 324 of file binary_tests.cpp.

324 {
325 using backend_t = backend<standalone_function_t, TestType>;
326 auto code = read_wasm( std::string(wasm_directory) + "binary.54.wasm");
327 backend_t bkend( code, &wa );
328
329}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [51/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_5_wasm>" ,
"" [binary_5_wasm_tests] )

Definition at line 293 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_6_wasm>" ,
"" [binary_6_wasm_tests] )

Definition at line 331 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_7_wasm>" ,
"" [binary_7_wasm_tests] )

Definition at line 337 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [54/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_8_wasm>" ,
"" [binary_8_wasm_tests] )

Definition at line 343 of file binary_tests.cpp.

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

◆ BACKEND_TEST_CASE() [55/55]

BACKEND_TEST_CASE ( "Testing wasm <binary_9_wasm>" ,
"" [binary_9_wasm_tests] )

Definition at line 349 of file binary_tests.cpp.

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

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.