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

Go to the source code of this file.

Functions

 BACKEND_TEST_CASE ("Testing wasm <local_tee_0_wasm>", "[local_tee_0_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_1_wasm>", "[local_tee_1_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_10_wasm>", "[local_tee_10_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_11_wasm>", "[local_tee_11_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_12_wasm>", "[local_tee_12_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_13_wasm>", "[local_tee_13_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_14_wasm>", "[local_tee_14_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_15_wasm>", "[local_tee_15_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_16_wasm>", "[local_tee_16_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_17_wasm>", "[local_tee_17_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_18_wasm>", "[local_tee_18_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_19_wasm>", "[local_tee_19_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_2_wasm>", "[local_tee_2_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_20_wasm>", "[local_tee_20_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_21_wasm>", "[local_tee_21_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_22_wasm>", "[local_tee_22_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_23_wasm>", "[local_tee_23_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_24_wasm>", "[local_tee_24_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_25_wasm>", "[local_tee_25_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_26_wasm>", "[local_tee_26_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_27_wasm>", "[local_tee_27_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_28_wasm>", "[local_tee_28_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_29_wasm>", "[local_tee_29_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_3_wasm>", "[local_tee_3_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_30_wasm>", "[local_tee_30_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_31_wasm>", "[local_tee_31_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_32_wasm>", "[local_tee_32_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_33_wasm>", "[local_tee_33_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_34_wasm>", "[local_tee_34_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_35_wasm>", "[local_tee_35_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_36_wasm>", "[local_tee_36_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_37_wasm>", "[local_tee_37_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_38_wasm>", "[local_tee_38_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_39_wasm>", "[local_tee_39_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_4_wasm>", "[local_tee_4_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_40_wasm>", "[local_tee_40_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_41_wasm>", "[local_tee_41_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_5_wasm>", "[local_tee_5_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_6_wasm>", "[local_tee_6_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_7_wasm>", "[local_tee_7_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_8_wasm>", "[local_tee_8_wasm_tests]")
 
 BACKEND_TEST_CASE ("Testing wasm <local_tee_9_wasm>", "[local_tee_9_wasm_tests]")
 

Variables

wasm_allocator wa
 

Function Documentation

◆ BACKEND_TEST_CASE() [1/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_0_wasm>" ,
"" [local_tee_0_wasm_tests] )

Definition at line 18 of file local_tee_tests.cpp.

18 {
19 using backend_t = backend<standalone_function_t, TestType>;
20 auto code = read_wasm( std::string(wasm_directory) + "local_tee.0.wasm");
21 backend_t bkend( code, &wa );
22
23 CHECK(bkend.call_with_return("env", "type-local-i32")->to_ui32() == UINT32_C(0));
24 CHECK(bkend.call_with_return("env", "type-local-i64")->to_ui64() == UINT32_C(0));
25 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "type-local-f32")->to_f32()) == UINT32_C(0));
26 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "type-local-f64")->to_f64()) == UINT64_C(0));
27 CHECK(bkend.call_with_return("env", "type-param-i32", UINT32_C(2))->to_ui32() == UINT32_C(10));
28 CHECK(bkend.call_with_return("env", "type-param-i64", UINT64_C(3))->to_ui64() == UINT32_C(11));
29 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "type-param-f32", bit_cast<float>(UINT32_C(1082969293)))->to_f32()) == UINT32_C(1093769626));
30 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "type-param-f64", bit_cast<double>(UINT64_C(4617878467915022336)))->to_f64()) == UINT64_C(4623057607486498406));
31 CHECK(bkend.call_with_return("env", "as-block-first", UINT32_C(0))->to_ui32() == UINT32_C(1));
32 CHECK(bkend.call_with_return("env", "as-block-mid", UINT32_C(0))->to_ui32() == UINT32_C(1));
33 CHECK(bkend.call_with_return("env", "as-block-last", UINT32_C(0))->to_ui32() == UINT32_C(1));
34 CHECK(bkend.call_with_return("env", "as-loop-first", UINT32_C(0))->to_ui32() == UINT32_C(3));
35 CHECK(bkend.call_with_return("env", "as-loop-mid", UINT32_C(0))->to_ui32() == UINT32_C(4));
36 CHECK(bkend.call_with_return("env", "as-loop-last", UINT32_C(0))->to_ui32() == UINT32_C(5));
37 CHECK(bkend.call_with_return("env", "as-br-value", UINT32_C(0))->to_ui32() == UINT32_C(9));
38 CHECK(!bkend.call_with_return("env", "as-br_if-cond", UINT32_C(0)));
39 CHECK(bkend.call_with_return("env", "as-br_if-value", UINT32_C(0))->to_ui32() == UINT32_C(8));
40 CHECK(bkend.call_with_return("env", "as-br_if-value-cond", UINT32_C(0))->to_ui32() == UINT32_C(6));
41 CHECK(!bkend.call_with_return("env", "as-br_table-index", UINT32_C(0)));
42 CHECK(bkend.call_with_return("env", "as-br_table-value", UINT32_C(0))->to_ui32() == UINT32_C(10));
43 CHECK(bkend.call_with_return("env", "as-br_table-value-index", UINT32_C(0))->to_ui32() == UINT32_C(6));
44 CHECK(bkend.call_with_return("env", "as-return-value", UINT32_C(0))->to_ui32() == UINT32_C(7));
45 CHECK(bkend.call_with_return("env", "as-if-cond", UINT32_C(0))->to_ui32() == UINT32_C(0));
46 CHECK(bkend.call_with_return("env", "as-if-then", UINT32_C(1))->to_ui32() == UINT32_C(3));
47 CHECK(bkend.call_with_return("env", "as-if-else", UINT32_C(0))->to_ui32() == UINT32_C(4));
48 CHECK(bkend.call_with_return("env", "as-select-first", UINT32_C(0), UINT32_C(1))->to_ui32() == UINT32_C(5));
49 CHECK(bkend.call_with_return("env", "as-select-second", UINT32_C(0), UINT32_C(0))->to_ui32() == UINT32_C(6));
50 CHECK(bkend.call_with_return("env", "as-select-cond", UINT32_C(0))->to_ui32() == UINT32_C(0));
51 CHECK(bkend.call_with_return("env", "as-call-first", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
52 CHECK(bkend.call_with_return("env", "as-call-mid", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
53 CHECK(bkend.call_with_return("env", "as-call-last", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
54 CHECK(bkend.call_with_return("env", "as-call_indirect-first", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
55 CHECK(bkend.call_with_return("env", "as-call_indirect-mid", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
56 CHECK(bkend.call_with_return("env", "as-call_indirect-last", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
57 CHECK(bkend.call_with_return("env", "as-call_indirect-index", UINT32_C(0))->to_ui32() == UINT32_C(4294967295));
58 CHECK(!bkend.call_with_return("env", "as-local.set-value"));
59 CHECK(bkend.call_with_return("env", "as-local.tee-value", UINT32_C(0))->to_ui32() == UINT32_C(1));
60 CHECK(!bkend.call_with_return("env", "as-global.set-value"));
61 CHECK(bkend.call_with_return("env", "as-load-address", UINT32_C(0))->to_ui32() == UINT32_C(0));
62 CHECK(bkend.call_with_return("env", "as-loadN-address", UINT32_C(0))->to_ui32() == UINT32_C(0));
63 CHECK(!bkend.call_with_return("env", "as-store-address", UINT32_C(0)));
64 CHECK(!bkend.call_with_return("env", "as-store-value", UINT32_C(0)));
65 CHECK(!bkend.call_with_return("env", "as-storeN-address", UINT32_C(0)));
66 CHECK(!bkend.call_with_return("env", "as-storeN-value", UINT32_C(0)));
67 CHECK(bit_cast<uint32_t>(bkend.call_with_return("env", "as-unary-operand", bit_cast<float>(UINT32_C(0)))->to_f32()) == UINT32_C(4286640610));
68 CHECK(bkend.call_with_return("env", "as-binary-left", UINT32_C(0))->to_ui32() == UINT32_C(13));
69 CHECK(bkend.call_with_return("env", "as-binary-right", UINT32_C(0))->to_ui32() == UINT32_C(6));
70 CHECK(bkend.call_with_return("env", "as-test-operand", UINT32_C(0))->to_ui32() == UINT32_C(1));
71 CHECK(bkend.call_with_return("env", "as-compare-left", UINT32_C(0))->to_ui32() == UINT32_C(0));
72 CHECK(bkend.call_with_return("env", "as-compare-right", UINT32_C(0))->to_ui32() == UINT32_C(1));
73 CHECK(bkend.call_with_return("env", "as-convert-operand", UINT64_C(0))->to_ui32() == UINT32_C(41));
74 CHECK(bkend.call_with_return("env", "as-memory.grow-size", UINT32_C(0))->to_ui32() == UINT32_C(1));
75 CHECK(!bkend.call_with_return("env", "type-mixed", UINT64_C(1), bit_cast<float>(UINT32_C(1074580685)), bit_cast<double>(UINT64_C(4614613358185178726)), UINT32_C(4), UINT32_C(5)));
76 CHECK(bkend.call_with_return("env", "write", UINT64_C(1), bit_cast<float>(UINT32_C(1073741824)), bit_cast<double>(UINT64_C(4614613358185178726)), UINT32_C(4), UINT32_C(5))->to_ui64() == UINT32_C(56));
77 CHECK(bit_cast<uint64_t>(bkend.call_with_return("env", "result", UINT64_C(18446744073709551615), bit_cast<float>(UINT32_C(3221225472)), bit_cast<double>(UINT64_C(13837985395039954534)), UINT32_C(4294967292), UINT32_C(4294967291))->to_f64()) == UINT64_C(4630094481904264806));
78}
sysio::vm::backend::call_with_return
auto call_with_return(host_t &host, const std::string_view &mod, const std::string_view &func, Args... args)
Definition backend.hpp:178
CHECK
#define CHECK(cond)
Definition util.h:80
bkend
backend_t bkend(hello_wasm, ehm, &wa)
wa
wasm_allocator wa
Definition main.cpp:10
sysio::vm::read_wasm
std::vector< uint8_t > read_wasm(const std::string &fname)
Definition utils.hpp:30
UINT32_C
#define UINT32_C(val)
Definition stdint.h:283
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() [2/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_10_wasm>" ,
"" [local_tee_10_wasm_tests] )

Definition at line 86 of file local_tee_tests.cpp.

86 {
87 using backend_t = backend<standalone_function_t, TestType>;
88 auto code = read_wasm( std::string(wasm_directory) + "local_tee.10.wasm");
89 CHECK_THROWS_AS(backend_t(code, nullptr), std::exception);
90}
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/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_11_wasm>" ,
"" [local_tee_11_wasm_tests] )

Definition at line 92 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [4/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_12_wasm>" ,
"" [local_tee_12_wasm_tests] )

Definition at line 98 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [5/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_13_wasm>" ,
"" [local_tee_13_wasm_tests] )

Definition at line 104 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [6/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_14_wasm>" ,
"" [local_tee_14_wasm_tests] )

Definition at line 110 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [7/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_15_wasm>" ,
"" [local_tee_15_wasm_tests] )

Definition at line 116 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [8/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_16_wasm>" ,
"" [local_tee_16_wasm_tests] )

Definition at line 122 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [9/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_17_wasm>" ,
"" [local_tee_17_wasm_tests] )

Definition at line 128 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [10/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_18_wasm>" ,
"" [local_tee_18_wasm_tests] )

Definition at line 134 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [11/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_19_wasm>" ,
"" [local_tee_19_wasm_tests] )

Definition at line 140 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [12/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_1_wasm>" ,
"" [local_tee_1_wasm_tests] )

Definition at line 80 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [13/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_20_wasm>" ,
"" [local_tee_20_wasm_tests] )

Definition at line 152 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [14/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_21_wasm>" ,
"" [local_tee_21_wasm_tests] )

Definition at line 158 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [15/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_22_wasm>" ,
"" [local_tee_22_wasm_tests] )

Definition at line 164 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [16/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_23_wasm>" ,
"" [local_tee_23_wasm_tests] )

Definition at line 170 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [17/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_24_wasm>" ,
"" [local_tee_24_wasm_tests] )

Definition at line 176 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [18/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_25_wasm>" ,
"" [local_tee_25_wasm_tests] )

Definition at line 182 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [19/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_26_wasm>" ,
"" [local_tee_26_wasm_tests] )

Definition at line 188 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [20/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_27_wasm>" ,
"" [local_tee_27_wasm_tests] )

Definition at line 194 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [21/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_28_wasm>" ,
"" [local_tee_28_wasm_tests] )

Definition at line 200 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [22/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_29_wasm>" ,
"" [local_tee_29_wasm_tests] )

Definition at line 206 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [23/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_2_wasm>" ,
"" [local_tee_2_wasm_tests] )

Definition at line 146 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [24/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_30_wasm>" ,
"" [local_tee_30_wasm_tests] )

Definition at line 218 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [25/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_31_wasm>" ,
"" [local_tee_31_wasm_tests] )

Definition at line 224 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [26/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_32_wasm>" ,
"" [local_tee_32_wasm_tests] )

Definition at line 230 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [27/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_33_wasm>" ,
"" [local_tee_33_wasm_tests] )

Definition at line 236 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [28/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_34_wasm>" ,
"" [local_tee_34_wasm_tests] )

Definition at line 242 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [29/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_35_wasm>" ,
"" [local_tee_35_wasm_tests] )

Definition at line 248 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [30/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_36_wasm>" ,
"" [local_tee_36_wasm_tests] )

Definition at line 254 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [31/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_37_wasm>" ,
"" [local_tee_37_wasm_tests] )

Definition at line 260 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [32/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_38_wasm>" ,
"" [local_tee_38_wasm_tests] )

Definition at line 266 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [33/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_39_wasm>" ,
"" [local_tee_39_wasm_tests] )

Definition at line 272 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [34/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_3_wasm>" ,
"" [local_tee_3_wasm_tests] )

Definition at line 212 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [35/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_40_wasm>" ,
"" [local_tee_40_wasm_tests] )

Definition at line 284 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [36/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_41_wasm>" ,
"" [local_tee_41_wasm_tests] )

Definition at line 290 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [37/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_4_wasm>" ,
"" [local_tee_4_wasm_tests] )

Definition at line 278 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [38/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_5_wasm>" ,
"" [local_tee_5_wasm_tests] )

Definition at line 296 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [39/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_6_wasm>" ,
"" [local_tee_6_wasm_tests] )

Definition at line 302 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [40/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_7_wasm>" ,
"" [local_tee_7_wasm_tests] )

Definition at line 308 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [41/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_8_wasm>" ,
"" [local_tee_8_wasm_tests] )

Definition at line 314 of file local_tee_tests.cpp.

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

◆ BACKEND_TEST_CASE() [42/42]

BACKEND_TEST_CASE ( "Testing wasm <local_tee_9_wasm>" ,
"" [local_tee_9_wasm_tests] )

Definition at line 320 of file local_tee_tests.cpp.

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

Variable Documentation

◆ wa

wasm_allocator wa
extern

Definition at line 10 of file main.cpp.