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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <align_0_wasm>", "[align_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_1_wasm>", "[align_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_10_wasm>", "[align_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_100_wasm>", "[align_100_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_101_wasm>", "[align_101_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_102_wasm>", "[align_102_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_103_wasm>", "[align_103_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_104_wasm>", "[align_104_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_105_wasm>", "[align_105_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_106_wasm>", "[align_106_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_107_wasm>", "[align_107_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_11_wasm>", "[align_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_12_wasm>", "[align_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_13_wasm>", "[align_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_14_wasm>", "[align_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_15_wasm>", "[align_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_16_wasm>", "[align_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_17_wasm>", "[align_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_18_wasm>", "[align_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_19_wasm>", "[align_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_2_wasm>", "[align_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_20_wasm>", "[align_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_21_wasm>", "[align_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_22_wasm>", "[align_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_3_wasm>", "[align_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_4_wasm>", "[align_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_5_wasm>", "[align_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_6_wasm>", "[align_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_69_wasm>", "[align_69_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_7_wasm>", "[align_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_70_wasm>", "[align_70_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_71_wasm>", "[align_71_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_72_wasm>", "[align_72_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_73_wasm>", "[align_73_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_74_wasm>", "[align_74_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_75_wasm>", "[align_75_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_76_wasm>", "[align_76_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_77_wasm>", "[align_77_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_78_wasm>", "[align_78_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_79_wasm>", "[align_79_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_8_wasm>", "[align_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_80_wasm>", "[align_80_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_81_wasm>", "[align_81_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_82_wasm>", "[align_82_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_83_wasm>", "[align_83_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_84_wasm>", "[align_84_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_85_wasm>", "[align_85_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_86_wasm>", "[align_86_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_87_wasm>", "[align_87_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_88_wasm>", "[align_88_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_89_wasm>", "[align_89_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_9_wasm>", "[align_9_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_90_wasm>", "[align_90_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_91_wasm>", "[align_91_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_92_wasm>", "[align_92_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_93_wasm>", "[align_93_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_94_wasm>", "[align_94_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_95_wasm>", "[align_95_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_96_wasm>", "[align_96_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_97_wasm>", "[align_97_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_98_wasm>", "[align_98_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <align_99_wasm>", "[align_99_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/62]

BACKEND_TEST_CASE ( "Testing wasm <align_0_wasm>" ,
"" [align_0_wasm_tests] )

Definition at line 18 of file align_tests.cpp.

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

BACKEND_TEST_CASE ( "Testing wasm <align_100_wasm>" ,
"" [align_100_wasm_tests] )

Definition at line 39 of file align_tests.cpp.

39 {
40 using backend_t = backend<standalone_function_t, TestType>;
41 auto code = read_wasm( std::string(wasm_directory) + "align.100.wasm");
42 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
43}
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/62]

BACKEND_TEST_CASE ( "Testing wasm <align_101_wasm>" ,
"" [align_101_wasm_tests] )

Definition at line 45 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [4/62]

BACKEND_TEST_CASE ( "Testing wasm <align_102_wasm>" ,
"" [align_102_wasm_tests] )

Definition at line 51 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [5/62]

BACKEND_TEST_CASE ( "Testing wasm <align_103_wasm>" ,
"" [align_103_wasm_tests] )

Definition at line 57 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [6/62]

BACKEND_TEST_CASE ( "Testing wasm <align_104_wasm>" ,
"" [align_104_wasm_tests] )

Definition at line 63 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [7/62]

BACKEND_TEST_CASE ( "Testing wasm <align_105_wasm>" ,
"" [align_105_wasm_tests] )

Definition at line 69 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [8/62]

BACKEND_TEST_CASE ( "Testing wasm <align_106_wasm>" ,
"" [align_106_wasm_tests] )

Definition at line 75 of file align_tests.cpp.

75 {
76 using backend_t = backend<standalone_function_t, TestType>;
77 auto code = read_wasm( std::string(wasm_directory) + "align.106.wasm");
78 backend_t bkend( code, &wa );
79
80 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f32_align_switch", UINT32_C(0))->to_f32()) == UINT32_C(1092616192));
81 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f32_align_switch", UINT32_C(1))->to_f32()) == UINT32_C(1092616192));
82 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f32_align_switch", UINT32_C(2))->to_f32()) == UINT32_C(1092616192));
83 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "f32_align_switch", UINT32_C(3))->to_f32()) == UINT32_C(1092616192));
84 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f64_align_switch", UINT32_C(0))->to_f64()) == UINT64_C(4621819117588971520));
85 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f64_align_switch", UINT32_C(1))->to_f64()) == UINT64_C(4621819117588971520));
86 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f64_align_switch", UINT32_C(2))->to_f64()) == UINT64_C(4621819117588971520));
87 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f64_align_switch", UINT32_C(3))->to_f64()) == UINT64_C(4621819117588971520));
88 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "f64_align_switch", UINT32_C(4))->to_f64()) == UINT64_C(4621819117588971520));
89 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(0), UINT32_C(0))->to_ui32() == UINT32_C(10));
90 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(0), UINT32_C(1))->to_ui32() == UINT32_C(10));
91 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(1), UINT32_C(0))->to_ui32() == UINT32_C(10));
92 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(1), UINT32_C(1))->to_ui32() == UINT32_C(10));
93 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(2), UINT32_C(0))->to_ui32() == UINT32_C(10));
94 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(2), UINT32_C(1))->to_ui32() == UINT32_C(10));
95 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(2), UINT32_C(2))->to_ui32() == UINT32_C(10));
96 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(3), UINT32_C(0))->to_ui32() == UINT32_C(10));
97 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(3), UINT32_C(1))->to_ui32() == UINT32_C(10));
98 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(3), UINT32_C(2))->to_ui32() == UINT32_C(10));
99 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(4), UINT32_C(0))->to_ui32() == UINT32_C(10));
100 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(4), UINT32_C(1))->to_ui32() == UINT32_C(10));
101 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(4), UINT32_C(2))->to_ui32() == UINT32_C(10));
102 CHECK(bkend.call_with_return("env", "i32_align_switch", UINT32_C(4), UINT32_C(4))->to_ui32() == UINT32_C(10));
103 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(0), UINT32_C(0))->to_ui64() == UINT32_C(10));
104 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(0), UINT32_C(1))->to_ui64() == UINT32_C(10));
105 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(1), UINT32_C(0))->to_ui64() == UINT32_C(10));
106 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(1), UINT32_C(1))->to_ui64() == UINT32_C(10));
107 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(2), UINT32_C(0))->to_ui64() == UINT32_C(10));
108 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(2), UINT32_C(1))->to_ui64() == UINT32_C(10));
109 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(2), UINT32_C(2))->to_ui64() == UINT32_C(10));
110 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(3), UINT32_C(0))->to_ui64() == UINT32_C(10));
111 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(3), UINT32_C(1))->to_ui64() == UINT32_C(10));
112 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(3), UINT32_C(2))->to_ui64() == UINT32_C(10));
113 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(4), UINT32_C(0))->to_ui64() == UINT32_C(10));
114 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(4), UINT32_C(1))->to_ui64() == UINT32_C(10));
115 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(4), UINT32_C(2))->to_ui64() == UINT32_C(10));
116 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(4), UINT32_C(4))->to_ui64() == UINT32_C(10));
117 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(5), UINT32_C(0))->to_ui64() == UINT32_C(10));
118 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(5), UINT32_C(1))->to_ui64() == UINT32_C(10));
119 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(5), UINT32_C(2))->to_ui64() == UINT32_C(10));
120 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(5), UINT32_C(4))->to_ui64() == UINT32_C(10));
121 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(6), UINT32_C(0))->to_ui64() == UINT32_C(10));
122 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(6), UINT32_C(1))->to_ui64() == UINT32_C(10));
123 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(6), UINT32_C(2))->to_ui64() == UINT32_C(10));
124 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(6), UINT32_C(4))->to_ui64() == UINT32_C(10));
125 CHECK(bkend.call_with_return("env", "i64_align_switch", UINT32_C(6), UINT32_C(8))->to_ui64() == UINT32_C(10));
126}
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
UINT32_C
#define UINT32_C(val)
Definition stdint.h:283
UINT64_C
#define UINT64_C(val)
Definition stdint.h:284
bit_cast
T bit_cast(const U &u)
Definition utils.hpp:35
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [9/62]

BACKEND_TEST_CASE ( "Testing wasm <align_107_wasm>" ,
"" [align_107_wasm_tests] )

Definition at line 128 of file align_tests.cpp.

128 {
129 using backend_t = backend<standalone_function_t, TestType>;
130 auto code = read_wasm( std::string(wasm_directory) + "align.107.wasm");
131 backend_t bkend( code, &wa );
132
133 CHECK_THROWS_AS(bkend("env", "store", UINT32_C(65532), UINT64_C(18446744073709551615)), std::exception);
134 CHECK(bkend.call_with_return("env", "load", UINT32_C(65532))->to_ui32() == UINT32_C(0));
135}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [10/62]

BACKEND_TEST_CASE ( "Testing wasm <align_10_wasm>" ,
"" [align_10_wasm_tests] )

Definition at line 32 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [11/62]

BACKEND_TEST_CASE ( "Testing wasm <align_11_wasm>" ,
"" [align_11_wasm_tests] )

Definition at line 137 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/62]

BACKEND_TEST_CASE ( "Testing wasm <align_12_wasm>" ,
"" [align_12_wasm_tests] )

Definition at line 144 of file align_tests.cpp.

144 {
145 using backend_t = backend<standalone_function_t, TestType>;
146 auto code = read_wasm( std::string(wasm_directory) + "align.12.wasm");
147 backend_t bkend( code, &wa );
148
149}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [13/62]

BACKEND_TEST_CASE ( "Testing wasm <align_13_wasm>" ,
"" [align_13_wasm_tests] )

Definition at line 151 of file align_tests.cpp.

151 {
152 using backend_t = backend<standalone_function_t, TestType>;
153 auto code = read_wasm( std::string(wasm_directory) + "align.13.wasm");
154 backend_t bkend( code, &wa );
155
156}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [14/62]

BACKEND_TEST_CASE ( "Testing wasm <align_14_wasm>" ,
"" [align_14_wasm_tests] )

Definition at line 158 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/62]

BACKEND_TEST_CASE ( "Testing wasm <align_15_wasm>" ,
"" [align_15_wasm_tests] )

Definition at line 165 of file align_tests.cpp.

165 {
166 using backend_t = backend<standalone_function_t, TestType>;
167 auto code = read_wasm( std::string(wasm_directory) + "align.15.wasm");
168 backend_t bkend( code, &wa );
169
170}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [16/62]

BACKEND_TEST_CASE ( "Testing wasm <align_16_wasm>" ,
"" [align_16_wasm_tests] )

Definition at line 172 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/62]

BACKEND_TEST_CASE ( "Testing wasm <align_17_wasm>" ,
"" [align_17_wasm_tests] )

Definition at line 179 of file align_tests.cpp.

179 {
180 using backend_t = backend<standalone_function_t, TestType>;
181 auto code = read_wasm( std::string(wasm_directory) + "align.17.wasm");
182 backend_t bkend( code, &wa );
183
184}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [18/62]

BACKEND_TEST_CASE ( "Testing wasm <align_18_wasm>" ,
"" [align_18_wasm_tests] )

Definition at line 186 of file align_tests.cpp.

186 {
187 using backend_t = backend<standalone_function_t, TestType>;
188 auto code = read_wasm( std::string(wasm_directory) + "align.18.wasm");
189 backend_t bkend( code, &wa );
190
191}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [19/62]

BACKEND_TEST_CASE ( "Testing wasm <align_19_wasm>" ,
"" [align_19_wasm_tests] )

Definition at line 193 of file align_tests.cpp.

193 {
194 using backend_t = backend<standalone_function_t, TestType>;
195 auto code = read_wasm( std::string(wasm_directory) + "align.19.wasm");
196 backend_t bkend( code, &wa );
197
198}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [20/62]

BACKEND_TEST_CASE ( "Testing wasm <align_1_wasm>" ,
"" [align_1_wasm_tests] )

Definition at line 25 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/62]

BACKEND_TEST_CASE ( "Testing wasm <align_20_wasm>" ,
"" [align_20_wasm_tests] )

Definition at line 207 of file align_tests.cpp.

207 {
208 using backend_t = backend<standalone_function_t, TestType>;
209 auto code = read_wasm( std::string(wasm_directory) + "align.20.wasm");
210 backend_t bkend( code, &wa );
211
212}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [22/62]

BACKEND_TEST_CASE ( "Testing wasm <align_21_wasm>" ,
"" [align_21_wasm_tests] )

Definition at line 214 of file align_tests.cpp.

214 {
215 using backend_t = backend<standalone_function_t, TestType>;
216 auto code = read_wasm( std::string(wasm_directory) + "align.21.wasm");
217 backend_t bkend( code, &wa );
218
219}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [23/62]

BACKEND_TEST_CASE ( "Testing wasm <align_22_wasm>" ,
"" [align_22_wasm_tests] )

Definition at line 221 of file align_tests.cpp.

221 {
222 using backend_t = backend<standalone_function_t, TestType>;
223 auto code = read_wasm( std::string(wasm_directory) + "align.22.wasm");
224 backend_t bkend( code, &wa );
225
226}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [24/62]

BACKEND_TEST_CASE ( "Testing wasm <align_2_wasm>" ,
"" [align_2_wasm_tests] )

Definition at line 200 of file align_tests.cpp.

200 {
201 using backend_t = backend<standalone_function_t, TestType>;
202 auto code = read_wasm( std::string(wasm_directory) + "align.2.wasm");
203 backend_t bkend( code, &wa );
204
205}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [25/62]

BACKEND_TEST_CASE ( "Testing wasm <align_3_wasm>" ,
"" [align_3_wasm_tests] )

Definition at line 228 of file align_tests.cpp.

228 {
229 using backend_t = backend<standalone_function_t, TestType>;
230 auto code = read_wasm( std::string(wasm_directory) + "align.3.wasm");
231 backend_t bkend( code, &wa );
232
233}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [26/62]

BACKEND_TEST_CASE ( "Testing wasm <align_4_wasm>" ,
"" [align_4_wasm_tests] )

Definition at line 235 of file align_tests.cpp.

235 {
236 using backend_t = backend<standalone_function_t, TestType>;
237 auto code = read_wasm( std::string(wasm_directory) + "align.4.wasm");
238 backend_t bkend( code, &wa );
239
240}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [27/62]

BACKEND_TEST_CASE ( "Testing wasm <align_5_wasm>" ,
"" [align_5_wasm_tests] )

Definition at line 242 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/62]

BACKEND_TEST_CASE ( "Testing wasm <align_69_wasm>" ,
"" [align_69_wasm_tests] )

Definition at line 256 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/62]

BACKEND_TEST_CASE ( "Testing wasm <align_6_wasm>" ,
"" [align_6_wasm_tests] )

Definition at line 249 of file align_tests.cpp.

249 {
250 using backend_t = backend<standalone_function_t, TestType>;
251 auto code = read_wasm( std::string(wasm_directory) + "align.6.wasm");
252 backend_t bkend( code, &wa );
253
254}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [30/62]

BACKEND_TEST_CASE ( "Testing wasm <align_70_wasm>" ,
"" [align_70_wasm_tests] )

Definition at line 269 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/62]

BACKEND_TEST_CASE ( "Testing wasm <align_71_wasm>" ,
"" [align_71_wasm_tests] )

Definition at line 275 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/62]

BACKEND_TEST_CASE ( "Testing wasm <align_72_wasm>" ,
"" [align_72_wasm_tests] )

Definition at line 281 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/62]

BACKEND_TEST_CASE ( "Testing wasm <align_73_wasm>" ,
"" [align_73_wasm_tests] )

Definition at line 287 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/62]

BACKEND_TEST_CASE ( "Testing wasm <align_74_wasm>" ,
"" [align_74_wasm_tests] )

Definition at line 293 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/62]

BACKEND_TEST_CASE ( "Testing wasm <align_75_wasm>" ,
"" [align_75_wasm_tests] )

Definition at line 299 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/62]

BACKEND_TEST_CASE ( "Testing wasm <align_76_wasm>" ,
"" [align_76_wasm_tests] )

Definition at line 305 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/62]

BACKEND_TEST_CASE ( "Testing wasm <align_77_wasm>" ,
"" [align_77_wasm_tests] )

Definition at line 311 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/62]

BACKEND_TEST_CASE ( "Testing wasm <align_78_wasm>" ,
"" [align_78_wasm_tests] )

Definition at line 317 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/62]

BACKEND_TEST_CASE ( "Testing wasm <align_79_wasm>" ,
"" [align_79_wasm_tests] )

Definition at line 323 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/62]

BACKEND_TEST_CASE ( "Testing wasm <align_7_wasm>" ,
"" [align_7_wasm_tests] )

Definition at line 262 of file align_tests.cpp.

262 {
263 using backend_t = backend<standalone_function_t, TestType>;
264 auto code = read_wasm( std::string(wasm_directory) + "align.7.wasm");
265 backend_t bkend( code, &wa );
266
267}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [41/62]

BACKEND_TEST_CASE ( "Testing wasm <align_80_wasm>" ,
"" [align_80_wasm_tests] )

Definition at line 336 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/62]

BACKEND_TEST_CASE ( "Testing wasm <align_81_wasm>" ,
"" [align_81_wasm_tests] )

Definition at line 342 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [43/62]

BACKEND_TEST_CASE ( "Testing wasm <align_82_wasm>" ,
"" [align_82_wasm_tests] )

Definition at line 348 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [44/62]

BACKEND_TEST_CASE ( "Testing wasm <align_83_wasm>" ,
"" [align_83_wasm_tests] )

Definition at line 354 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [45/62]

BACKEND_TEST_CASE ( "Testing wasm <align_84_wasm>" ,
"" [align_84_wasm_tests] )

Definition at line 360 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [46/62]

BACKEND_TEST_CASE ( "Testing wasm <align_85_wasm>" ,
"" [align_85_wasm_tests] )

Definition at line 366 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [47/62]

BACKEND_TEST_CASE ( "Testing wasm <align_86_wasm>" ,
"" [align_86_wasm_tests] )

Definition at line 372 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [48/62]

BACKEND_TEST_CASE ( "Testing wasm <align_87_wasm>" ,
"" [align_87_wasm_tests] )

Definition at line 378 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [49/62]

BACKEND_TEST_CASE ( "Testing wasm <align_88_wasm>" ,
"" [align_88_wasm_tests] )

Definition at line 384 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [50/62]

BACKEND_TEST_CASE ( "Testing wasm <align_89_wasm>" ,
"" [align_89_wasm_tests] )

Definition at line 390 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [51/62]

BACKEND_TEST_CASE ( "Testing wasm <align_8_wasm>" ,
"" [align_8_wasm_tests] )

Definition at line 329 of file align_tests.cpp.

329 {
330 using backend_t = backend<standalone_function_t, TestType>;
331 auto code = read_wasm( std::string(wasm_directory) + "align.8.wasm");
332 backend_t bkend( code, &wa );
333
334}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [52/62]

BACKEND_TEST_CASE ( "Testing wasm <align_90_wasm>" ,
"" [align_90_wasm_tests] )

Definition at line 403 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [53/62]

BACKEND_TEST_CASE ( "Testing wasm <align_91_wasm>" ,
"" [align_91_wasm_tests] )

Definition at line 409 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [54/62]

BACKEND_TEST_CASE ( "Testing wasm <align_92_wasm>" ,
"" [align_92_wasm_tests] )

Definition at line 415 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [55/62]

BACKEND_TEST_CASE ( "Testing wasm <align_93_wasm>" ,
"" [align_93_wasm_tests] )

Definition at line 421 of file align_tests.cpp.

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

◆ BACKEND_TEST_CASE() [56/62]

BACKEND_TEST_CASE ( "Testing wasm <align_94_wasm>" ,
"" [align_94_wasm_tests] )

Definition at line 427 of file align_tests.cpp.

427 {
428 using backend_t = backend<standalone_function_t, TestType>;
429 auto code = read_wasm( std::string(wasm_directory) + "align.94.wasm");
430 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
431}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [57/62]

BACKEND_TEST_CASE ( "Testing wasm <align_95_wasm>" ,
"" [align_95_wasm_tests] )

Definition at line 433 of file align_tests.cpp.

433 {
434 using backend_t = backend<standalone_function_t, TestType>;
435 auto code = read_wasm( std::string(wasm_directory) + "align.95.wasm");
436 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
437}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [58/62]

BACKEND_TEST_CASE ( "Testing wasm <align_96_wasm>" ,
"" [align_96_wasm_tests] )

Definition at line 439 of file align_tests.cpp.

439 {
440 using backend_t = backend<standalone_function_t, TestType>;
441 auto code = read_wasm( std::string(wasm_directory) + "align.96.wasm");
442 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
443}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [59/62]

BACKEND_TEST_CASE ( "Testing wasm <align_97_wasm>" ,
"" [align_97_wasm_tests] )

Definition at line 445 of file align_tests.cpp.

445 {
446 using backend_t = backend<standalone_function_t, TestType>;
447 auto code = read_wasm( std::string(wasm_directory) + "align.97.wasm");
448 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
449}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [60/62]

BACKEND_TEST_CASE ( "Testing wasm <align_98_wasm>" ,
"" [align_98_wasm_tests] )

Definition at line 451 of file align_tests.cpp.

451 {
452 using backend_t = backend<standalone_function_t, TestType>;
453 auto code = read_wasm( std::string(wasm_directory) + "align.98.wasm");
454 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
455}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [61/62]

BACKEND_TEST_CASE ( "Testing wasm <align_99_wasm>" ,
"" [align_99_wasm_tests] )

Definition at line 457 of file align_tests.cpp.

457 {
458 using backend_t = backend<standalone_function_t, TestType>;
459 auto code = read_wasm( std::string(wasm_directory) + "align.99.wasm");
460 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
461}
Here is the call graph for this function:

◆ BACKEND_TEST_CASE() [62/62]

BACKEND_TEST_CASE ( "Testing wasm <align_9_wasm>" ,
"" [align_9_wasm_tests] )

Definition at line 396 of file align_tests.cpp.

396 {
397 using backend_t = backend<standalone_function_t, TestType>;
398 auto code = read_wasm( std::string(wasm_directory) + "align.9.wasm");
399 backend_t bkend( code, &wa );
400
401}
Here is the call graph for this function:

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.