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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_0_wasm>", "[binary-leb128_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_1_wasm>", "[binary-leb128_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_10_wasm>", "[binary-leb128_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_11_wasm>", "[binary-leb128_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_12_wasm>", "[binary-leb128_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_13_wasm>", "[binary-leb128_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_14_wasm>", "[binary-leb128_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_15_wasm>", "[binary-leb128_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_16_wasm>", "[binary-leb128_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_17_wasm>", "[binary-leb128_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_18_wasm>", "[binary-leb128_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_19_wasm>", "[binary-leb128_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_2_wasm>", "[binary-leb128_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_20_wasm>", "[binary-leb128_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_21_wasm>", "[binary-leb128_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_22_wasm>", "[binary-leb128_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_23_wasm>", "[binary-leb128_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_24_wasm>", "[binary-leb128_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_25_wasm>", "[binary-leb128_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_26_wasm>", "[binary-leb128_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_27_wasm>", "[binary-leb128_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_28_wasm>", "[binary-leb128_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_29_wasm>", "[binary-leb128_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_3_wasm>", "[binary-leb128_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_30_wasm>", "[binary-leb128_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_31_wasm>", "[binary-leb128_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_32_wasm>", "[binary-leb128_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_33_wasm>", "[binary-leb128_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_34_wasm>", "[binary-leb128_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_35_wasm>", "[binary-leb128_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_36_wasm>", "[binary-leb128_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_37_wasm>", "[binary-leb128_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_38_wasm>", "[binary-leb128_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_39_wasm>", "[binary-leb128_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_4_wasm>", "[binary-leb128_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_40_wasm>", "[binary-leb128_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_41_wasm>", "[binary-leb128_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_42_wasm>", "[binary-leb128_42_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_43_wasm>", "[binary-leb128_43_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_44_wasm>", "[binary-leb128_44_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_45_wasm>", "[binary-leb128_45_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_46_wasm>", "[binary-leb128_46_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_47_wasm>", "[binary-leb128_47_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_48_wasm>", "[binary-leb128_48_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_49_wasm>", "[binary-leb128_49_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_5_wasm>", "[binary-leb128_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_50_wasm>", "[binary-leb128_50_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_51_wasm>", "[binary-leb128_51_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_52_wasm>", "[binary-leb128_52_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_53_wasm>", "[binary-leb128_53_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_54_wasm>", "[binary-leb128_54_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_55_wasm>", "[binary-leb128_55_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_56_wasm>", "[binary-leb128_56_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_57_wasm>", "[binary-leb128_57_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_58_wasm>", "[binary-leb128_58_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_59_wasm>", "[binary-leb128_59_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_6_wasm>", "[binary-leb128_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_60_wasm>", "[binary-leb128_60_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_61_wasm>", "[binary-leb128_61_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_62_wasm>", "[binary-leb128_62_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_63_wasm>", "[binary-leb128_63_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_64_wasm>", "[binary-leb128_64_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_65_wasm>", "[binary-leb128_65_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_66_wasm>", "[binary-leb128_66_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_67_wasm>", "[binary-leb128_67_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_68_wasm>", "[binary-leb128_68_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_69_wasm>", "[binary-leb128_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_7_wasm>", "[binary-leb128_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_70_wasm>", "[binary-leb128_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_71_wasm>", "[binary-leb128_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_72_wasm>", "[binary-leb128_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_73_wasm>", "[binary-leb128_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_74_wasm>", "[binary-leb128_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_75_wasm>", "[binary-leb128_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_76_wasm>", "[binary-leb128_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_77_wasm>", "[binary-leb128_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_78_wasm>", "[binary-leb128_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_79_wasm>", "[binary-leb128_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_8_wasm>", "[binary-leb128_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_80_wasm>", "[binary-leb128_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <binary-leb128_9_wasm>", "[binary-leb128_9_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_0_wasm>" ,
"" [binary-leb128_0_wasm_tests] )

Definition at line 18 of file binary-leb128_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.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/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_10_wasm>" ,
"" [binary-leb128_10_wasm_tests] )

Definition at line 32 of file binary-leb128_tests.cpp.

32 {
33 using backend_t = backend<standalone_function_t, TestType>;
34 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.10.wasm");
35 backend_t bkend( code, &wa );
36
37}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [3/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_11_wasm>" ,
"" [binary-leb128_11_wasm_tests] )

Definition at line 39 of file binary-leb128_tests.cpp.

39 {
40 using backend_t = backend<standalone_function_t, TestType>;
41 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.11.wasm");
42 backend_t bkend( code, &wa );
43
44}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [4/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_12_wasm>" ,
"" [binary-leb128_12_wasm_tests] )

Definition at line 46 of file binary-leb128_tests.cpp.

46 {
47 using backend_t = backend<standalone_function_t, TestType>;
48 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.12.wasm");
49 backend_t bkend( code, &wa );
50
51}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [5/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_13_wasm>" ,
"" [binary-leb128_13_wasm_tests] )

Definition at line 53 of file binary-leb128_tests.cpp.

53 {
54 using backend_t = backend<standalone_function_t, TestType>;
55 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.13.wasm");
56 backend_t bkend( code, &wa );
57
58}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [6/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_14_wasm>" ,
"" [binary-leb128_14_wasm_tests] )

Definition at line 60 of file binary-leb128_tests.cpp.

60 {
61 using backend_t = backend<standalone_function_t, TestType>;
62 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.14.wasm");
63 backend_t bkend( code, &wa );
64
65}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [7/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_15_wasm>" ,
"" [binary-leb128_15_wasm_tests] )

Definition at line 67 of file binary-leb128_tests.cpp.

67 {
68 using backend_t = backend<standalone_function_t, TestType>;
69 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.15.wasm");
70 backend_t bkend( code, &wa );
71
72}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [8/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_16_wasm>" ,
"" [binary-leb128_16_wasm_tests] )

Definition at line 74 of file binary-leb128_tests.cpp.

74 {
75 using backend_t = backend<standalone_function_t, TestType>;
76 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.16.wasm");
77 backend_t bkend( code, &wa );
78
79}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [9/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_17_wasm>" ,
"" [binary-leb128_17_wasm_tests] )

Definition at line 81 of file binary-leb128_tests.cpp.

81 {
82 using backend_t = backend<standalone_function_t, TestType>;
83 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.17.wasm");
84 backend_t bkend( code, &wa );
85
86}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_18_wasm>" ,
"" [binary-leb128_18_wasm_tests] )

Definition at line 88 of file binary-leb128_tests.cpp.

88 {
89 using backend_t = backend<standalone_function_t, TestType>;
90 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.18.wasm");
91 backend_t bkend( code, &wa );
92
93}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [11/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_19_wasm>" ,
"" [binary-leb128_19_wasm_tests] )

Definition at line 95 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_1_wasm>" ,
"" [binary-leb128_1_wasm_tests] )

Definition at line 25 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [13/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_20_wasm>" ,
"" [binary-leb128_20_wasm_tests] )

Definition at line 109 of file binary-leb128_tests.cpp.

109 {
110 using backend_t = backend<standalone_function_t, TestType>;
111 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.20.wasm");
112 backend_t bkend( code, &wa );
113
114}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [14/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_21_wasm>" ,
"" [binary-leb128_21_wasm_tests] )

Definition at line 116 of file binary-leb128_tests.cpp.

116 {
117 using backend_t = backend<standalone_function_t, TestType>;
118 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.21.wasm");
119 backend_t bkend( code, &wa );
120
121}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [15/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_22_wasm>" ,
"" [binary-leb128_22_wasm_tests] )

Definition at line 123 of file binary-leb128_tests.cpp.

123 {
124 using backend_t = backend<standalone_function_t, TestType>;
125 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.22.wasm");
126 backend_t bkend( code, &wa );
127
128}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [16/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_23_wasm>" ,
"" [binary-leb128_23_wasm_tests] )

Definition at line 130 of file binary-leb128_tests.cpp.

130 {
131 using backend_t = backend<standalone_function_t, TestType>;
132 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.23.wasm");
133 backend_t bkend( code, &wa );
134
135}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [17/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_24_wasm>" ,
"" [binary-leb128_24_wasm_tests] )

Definition at line 137 of file binary-leb128_tests.cpp.

137 {
138 using backend_t = backend<standalone_function_t, TestType>;
139 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.24.wasm");
140 backend_t bkend( code, &wa );
141
142}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [18/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_25_wasm>" ,
"" [binary-leb128_25_wasm_tests] )

Definition at line 144 of file binary-leb128_tests.cpp.

144 {
145 using backend_t = backend<standalone_function_t, TestType>;
146 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.25.wasm");
147 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
148}
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() [19/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_26_wasm>" ,
"" [binary-leb128_26_wasm_tests] )

Definition at line 150 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_27_wasm>" ,
"" [binary-leb128_27_wasm_tests] )

Definition at line 156 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_28_wasm>" ,
"" [binary-leb128_28_wasm_tests] )

Definition at line 162 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_29_wasm>" ,
"" [binary-leb128_29_wasm_tests] )

Definition at line 168 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_2_wasm>" ,
"" [binary-leb128_2_wasm_tests] )

Definition at line 102 of file binary-leb128_tests.cpp.

102 {
103 using backend_t = backend<standalone_function_t, TestType>;
104 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.2.wasm");
105 backend_t bkend( code, &wa );
106
107}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_30_wasm>" ,
"" [binary-leb128_30_wasm_tests] )

Definition at line 181 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_31_wasm>" ,
"" [binary-leb128_31_wasm_tests] )

Definition at line 187 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_32_wasm>" ,
"" [binary-leb128_32_wasm_tests] )

Definition at line 193 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_33_wasm>" ,
"" [binary-leb128_33_wasm_tests] )

Definition at line 199 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_34_wasm>" ,
"" [binary-leb128_34_wasm_tests] )

Definition at line 205 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_35_wasm>" ,
"" [binary-leb128_35_wasm_tests] )

Definition at line 211 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_36_wasm>" ,
"" [binary-leb128_36_wasm_tests] )

Definition at line 217 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_37_wasm>" ,
"" [binary-leb128_37_wasm_tests] )

Definition at line 223 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_38_wasm>" ,
"" [binary-leb128_38_wasm_tests] )

Definition at line 229 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_39_wasm>" ,
"" [binary-leb128_39_wasm_tests] )

Definition at line 235 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_3_wasm>" ,
"" [binary-leb128_3_wasm_tests] )

Definition at line 174 of file binary-leb128_tests.cpp.

174 {
175 using backend_t = backend<standalone_function_t, TestType>;
176 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.3.wasm");
177 backend_t bkend( code, &wa );
178
179}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [35/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_40_wasm>" ,
"" [binary-leb128_40_wasm_tests] )

Definition at line 248 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_41_wasm>" ,
"" [binary-leb128_41_wasm_tests] )

Definition at line 254 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_42_wasm>" ,
"" [binary-leb128_42_wasm_tests] )

Definition at line 260 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_43_wasm>" ,
"" [binary-leb128_43_wasm_tests] )

Definition at line 266 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_44_wasm>" ,
"" [binary-leb128_44_wasm_tests] )

Definition at line 272 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_45_wasm>" ,
"" [binary-leb128_45_wasm_tests] )

Definition at line 278 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_46_wasm>" ,
"" [binary-leb128_46_wasm_tests] )

Definition at line 284 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_47_wasm>" ,
"" [binary-leb128_47_wasm_tests] )

Definition at line 290 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_48_wasm>" ,
"" [binary-leb128_48_wasm_tests] )

Definition at line 296 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_49_wasm>" ,
"" [binary-leb128_49_wasm_tests] )

Definition at line 302 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_4_wasm>" ,
"" [binary-leb128_4_wasm_tests] )

Definition at line 241 of file binary-leb128_tests.cpp.

241 {
242 using backend_t = backend<standalone_function_t, TestType>;
243 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.4.wasm");
244 backend_t bkend( code, &wa );
245
246}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [46/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_50_wasm>" ,
"" [binary-leb128_50_wasm_tests] )

Definition at line 315 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_51_wasm>" ,
"" [binary-leb128_51_wasm_tests] )

Definition at line 321 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_52_wasm>" ,
"" [binary-leb128_52_wasm_tests] )

Definition at line 327 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_53_wasm>" ,
"" [binary-leb128_53_wasm_tests] )

Definition at line 333 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_54_wasm>" ,
"" [binary-leb128_54_wasm_tests] )

Definition at line 339 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_55_wasm>" ,
"" [binary-leb128_55_wasm_tests] )

Definition at line 345 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [52/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_56_wasm>" ,
"" [binary-leb128_56_wasm_tests] )

Definition at line 351 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_57_wasm>" ,
"" [binary-leb128_57_wasm_tests] )

Definition at line 357 of file binary-leb128_tests.cpp.

357 {
358 using backend_t = backend<standalone_function_t, TestType>;
359 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.57.wasm");
360 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
361}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [54/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_58_wasm>" ,
"" [binary-leb128_58_wasm_tests] )

Definition at line 363 of file binary-leb128_tests.cpp.

363 {
364 using backend_t = backend<standalone_function_t, TestType>;
365 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.58.wasm");
366 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
367}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [55/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_59_wasm>" ,
"" [binary-leb128_59_wasm_tests] )

Definition at line 369 of file binary-leb128_tests.cpp.

369 {
370 using backend_t = backend<standalone_function_t, TestType>;
371 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.59.wasm");
372 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
373}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [56/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_5_wasm>" ,
"" [binary-leb128_5_wasm_tests] )

Definition at line 308 of file binary-leb128_tests.cpp.

308 {
309 using backend_t = backend<standalone_function_t, TestType>;
310 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.5.wasm");
311 backend_t bkend( code, &wa );
312
313}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [57/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_60_wasm>" ,
"" [binary-leb128_60_wasm_tests] )

Definition at line 382 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [58/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_61_wasm>" ,
"" [binary-leb128_61_wasm_tests] )

Definition at line 388 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [59/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_62_wasm>" ,
"" [binary-leb128_62_wasm_tests] )

Definition at line 394 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [60/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_63_wasm>" ,
"" [binary-leb128_63_wasm_tests] )

Definition at line 400 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [61/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_64_wasm>" ,
"" [binary-leb128_64_wasm_tests] )

Definition at line 406 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [62/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_65_wasm>" ,
"" [binary-leb128_65_wasm_tests] )

Definition at line 412 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [63/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_66_wasm>" ,
"" [binary-leb128_66_wasm_tests] )

Definition at line 418 of file binary-leb128_tests.cpp.

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

◆ BACKEND_TEST_CASE() [64/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_67_wasm>" ,
"" [binary-leb128_67_wasm_tests] )

Definition at line 424 of file binary-leb128_tests.cpp.

424 {
425 using backend_t = backend<standalone_function_t, TestType>;
426 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.67.wasm");
427 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
428}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [65/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_68_wasm>" ,
"" [binary-leb128_68_wasm_tests] )

Definition at line 430 of file binary-leb128_tests.cpp.

430 {
431 using backend_t = backend<standalone_function_t, TestType>;
432 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.68.wasm");
433 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
434}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [66/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_69_wasm>" ,
"" [binary-leb128_69_wasm_tests] )

Definition at line 436 of file binary-leb128_tests.cpp.

436 {
437 using backend_t = backend<standalone_function_t, TestType>;
438 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.69.wasm");
439 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
440}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [67/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_6_wasm>" ,
"" [binary-leb128_6_wasm_tests] )

Definition at line 375 of file binary-leb128_tests.cpp.

375 {
376 using backend_t = backend<standalone_function_t, TestType>;
377 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.6.wasm");
378 backend_t bkend( code, &wa );
379
380}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [68/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_70_wasm>" ,
"" [binary-leb128_70_wasm_tests] )

Definition at line 449 of file binary-leb128_tests.cpp.

449 {
450 using backend_t = backend<standalone_function_t, TestType>;
451 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.70.wasm");
452 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
453}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [69/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_71_wasm>" ,
"" [binary-leb128_71_wasm_tests] )

Definition at line 455 of file binary-leb128_tests.cpp.

455 {
456 using backend_t = backend<standalone_function_t, TestType>;
457 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.71.wasm");
458 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
459}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [70/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_72_wasm>" ,
"" [binary-leb128_72_wasm_tests] )

Definition at line 461 of file binary-leb128_tests.cpp.

461 {
462 using backend_t = backend<standalone_function_t, TestType>;
463 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.72.wasm");
464 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
465}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [71/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_73_wasm>" ,
"" [binary-leb128_73_wasm_tests] )

Definition at line 467 of file binary-leb128_tests.cpp.

467 {
468 using backend_t = backend<standalone_function_t, TestType>;
469 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.73.wasm");
470 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
471}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [72/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_74_wasm>" ,
"" [binary-leb128_74_wasm_tests] )

Definition at line 473 of file binary-leb128_tests.cpp.

473 {
474 using backend_t = backend<standalone_function_t, TestType>;
475 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.74.wasm");
476 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
477}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [73/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_75_wasm>" ,
"" [binary-leb128_75_wasm_tests] )

Definition at line 479 of file binary-leb128_tests.cpp.

479 {
480 using backend_t = backend<standalone_function_t, TestType>;
481 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.75.wasm");
482 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
483}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [74/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_76_wasm>" ,
"" [binary-leb128_76_wasm_tests] )

Definition at line 485 of file binary-leb128_tests.cpp.

485 {
486 using backend_t = backend<standalone_function_t, TestType>;
487 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.76.wasm");
488 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
489}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [75/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_77_wasm>" ,
"" [binary-leb128_77_wasm_tests] )

Definition at line 491 of file binary-leb128_tests.cpp.

491 {
492 using backend_t = backend<standalone_function_t, TestType>;
493 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.77.wasm");
494 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
495}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [76/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_78_wasm>" ,
"" [binary-leb128_78_wasm_tests] )

Definition at line 497 of file binary-leb128_tests.cpp.

497 {
498 using backend_t = backend<standalone_function_t, TestType>;
499 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.78.wasm");
500 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
501}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [77/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_79_wasm>" ,
"" [binary-leb128_79_wasm_tests] )

Definition at line 503 of file binary-leb128_tests.cpp.

503 {
504 using backend_t = backend<standalone_function_t, TestType>;
505 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.79.wasm");
506 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
507}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [78/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_7_wasm>" ,
"" [binary-leb128_7_wasm_tests] )

Definition at line 442 of file binary-leb128_tests.cpp.

442 {
443 using backend_t = backend<standalone_function_t, TestType>;
444 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.7.wasm");
445 backend_t bkend( code, &wa );
446
447}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [79/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_80_wasm>" ,
"" [binary-leb128_80_wasm_tests] )

Definition at line 516 of file binary-leb128_tests.cpp.

516 {
517 using backend_t = backend<standalone_function_t, TestType>;
518 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.80.wasm");
519 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
520}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [80/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_8_wasm>" ,
"" [binary-leb128_8_wasm_tests] )

Definition at line 509 of file binary-leb128_tests.cpp.

509 {
510 using backend_t = backend<standalone_function_t, TestType>;
511 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.8.wasm");
512 backend_t bkend( code, &wa );
513
514}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [81/81]

BACKEND_TEST_CASE ( "Testing wasm <binary-leb128_9_wasm>" ,
"" [binary-leb128_9_wasm_tests] )

Definition at line 522 of file binary-leb128_tests.cpp.

522 {
523 using backend_t = backend<standalone_function_t, TestType>;
524 auto code = read_wasm( std::string(wasm_directory) + "binary-leb128.9.wasm");
525 backend_t bkend( code, &wa );
526
527}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.